TOC

Sichern und Wiederherstellen eines Kubernetes-Clusters auf DigitalOcean mit Heptio Ark

[.note] #Note: Das Ark-Projekt wurde inVelero umbenannt und hat in Version 0.11.0 mehrere Änderungen vorgenommen. Dieses Handbuch wird in Kürze aktualisiert, um diese Änderungen zu berücksichtigen. Vielen Dank für Ihre Geduld!
#

Einführung

Heptio Ark ist ein praktisches Sicherungswerkzeug für Kubernetes-Cluster, das Kubernetes-Objekte komprimiert und im Objektspeicher sichert. Mithilfe der Blockspeicher-Snapshot-Funktionen Ihres Cloud-Anbieters werden auch Snapshots der persistenten Volumes Ihres Clusters erstellt. Anschließend können Sie die Objekte und persistenten Volumes Ihres Clusters in einem früheren Zustand wiederherstellen.

MitDigitalOcean Ark Plugin von StackPointCloud können Sie den DigitalOcean-Blockspeicher verwenden, um einen Snapshot Ihrer persistenten Volumes zu erstellen, und Spaces, um Ihre Kubernetes-Objekte zu sichern. Wenn Sie einen Kubernetes-Cluster auf DigitalOcean ausführen, können Sie den Status Ihres Clusters schnell sichern und im Notfall wiederherstellen.

In diesem Lernprogramm werden wir den Ark-Client auf einem lokalen Computer einrichten und konfigurieren und den Ark-Server in unserem Kubernetes-Cluster bereitstellen. Anschließend stellen wir eine Nginx-Beispielanwendung bereit, die ein persistentes Volume für die Protokollierung verwendet, und simulieren ein Notfallwiederherstellungsszenario.

Voraussetzungen

Bevor Sie mit diesem Lernprogramm beginnen, sollten Sie Folgendes zur Verfügung haben:

Auf Ihrem lokalen Computer:

  • Das Befehlszeilentoolkubectl, das für die Verbindung mit Ihrem Cluster konfiguriert ist. Weitere Informationen zum Installieren und Konfigurieren vonkubectl finden Sie unterofficial Kubernetes documentation.

  • Das Befehlszeilenprogrammgit. Sie können lernen, wie Siegit inGetting Started with Git installieren.

In Ihrem DigitalOcean-Konto:

  • EinDigitalOcean Kubernetes-Cluster oder ein Kubernetes-Cluster (Version1.7.5 oder höher) auf DigitalOcean Droplets

  • Ein DNS-Server, der in Ihrem Cluster ausgeführt wird. Wenn Sie DigitalOcean Kubernetes verwenden, wird dies standardmäßig ausgeführt. Weitere Informationen zum Konfigurieren eines Kubernetes-DNS-Dienstes finden Sie inCustomizing DNS Service in der offiziellen Kuberentes-Dokumentation.

  • Ein DigitalOcean Space, in dem Ihre gesicherten Kubernetes-Objekte gespeichert werden. Um zu erfahren, wie ein Leerzeichen erstellt wird, konsultieren Siethe Spaces product documentation.

  • Ein Zugriffsschlüsselpaar für Ihren DigitalOcean Space. Informationen zum Erstellen eines Satzes von Zugriffsschlüsseln finden Sie unterHow to Manage Administrative Access to Spaces.

  • Ein persönliches Zugriffstoken zur Verwendung mit der DigitalOcean-API. Informationen zum Erstellen eines persönlichen Zugriffstokens finden Sie unterHow to Create a Personal Access Token.

Sobald Sie alle Einstellungen vorgenommen haben, können Sie mit dieser Anleitung beginnen.

[[Schritt-1 - Installieren des Arche-Clients]] == Schritt 1 - Installieren des Ark-Clients

Das Heptio Ark-Sicherungstool besteht aus einem Client, der auf Ihrem lokalen Computer installiert ist, und einem Server, der in Ihrem Kubernetes-Cluster ausgeführt wird. Zunächst installieren wir den lokalen Ark-Client.

Navigieren Sie in Ihrem Webbrowser zu Ark / Velero GitHub reporeleases page, suchen Sie die Version, die Ihrem Betriebssystem und Ihrer Systemarchitektur entspricht, und kopieren Sie die Linkadresse. Für die Zwecke dieses Handbuchs verwenden wir einen Ubuntu 18.04-Server auf einem x86-64- (oder AMD64-) Prozessor als lokalen Computer und die Version von Arkv0.10.0.

[.note] #Note: Um dieser Anleitung zu folgen, sollten Siev0.10.0 des Ark-Clients herunterladen und installieren.
#

Navigieren Sie dann über die Befehlszeile auf Ihrem lokalen Computer zum temporären Verzeichnis/tmp undcd hinein: 

cd /tmp

Verwenden Siewget und den zuvor kopierten Link, um den Release-Tarball herunterzuladen: 

wget https://link_copied_from_release_page

Extrahieren Sie nach Abschluss des Downloads den Tarball mittar (beachten Sie, dass der Dateiname je nach Release-Version und Betriebssystem unterschiedlich sein kann): 

tar -xvzf ark-v0.10.0-linux-amd64.tar.gz

Das Verzeichnis/tmpollte nun die extrahierte Binärdateiarkowie den Tarball enthalten, den Sie gerade heruntergeladen haben.

Stellen Sie sicher, dass Sie den Client vonarkausführen können, indem Sie die Binärdatei ausführen: 

./ark --help

Sie sollten die folgende Hilfeausgabe sehen: 

OutputHeptio Ark is a tool for managing disaster recovery, specifically for Kubernetes
cluster resources. It provides a simple, configurable, and operationally robust
way to back up your application state and associated data.

If you're familiar with kubectl, Ark supports a similar model, allowing you to
execute commands such as 'ark get backup' and 'ark create schedule'. The same
operations can also be performed as 'ark backup get' and 'ark schedule create'.

Usage:
  ark [command]

Available Commands:
  backup      Work with backups
  client      Ark client related commands
  completion  Output shell completion code for the specified shell (bash or zsh)
  create      Create ark resources
  delete      Delete ark resources
  describe    Describe ark resources
  get         Get ark resources
  help        Help about any command
  plugin      Work with plugins
  restic      Work with restic
  restore     Work with restores
  schedule    Work with schedules
  server      Run the ark server
  version     Print the ark version and associated image

. . .

Zu diesem Zeitpunkt sollten Sie die ausführbare Dateiarkaus dem temporären Verzeichnis/tmp verschieben und zu IhrenPATHhinzufügen. Um es zu IhrenPATH auf einem Ubuntu-System hinzuzufügen, kopieren Sie es einfach nach/usr/local/bin: 

sudo mv ark /usr/local/bin/ark

Sie können den Ark-Server jetzt konfigurieren und auf Ihrem Kubernetes-Cluster bereitstellen.

[[Schritt 2 - Installieren und Konfigurieren des Arche-Servers]] == Schritt 2 - Installieren und Konfigurieren des Ark-Servers

Bevor wir Ark in unserem Kubernetes-Cluster bereitstellen, erstellen wir zunächst die vorausgesetzten Objekte von Ark. Die Voraussetzungen für Ark bestehen aus:

  • Aheptio-ark Namespace

  • Das Dienstkonto vonark

  • Rollenbasierte Zugriffssteuerungsregeln (RBAC) zum Erteilen von Berechtigungen für das Dienstkonto vonark

  • Benutzerdefinierte Ressourcen (CRDs) für die Ark-spezifischen Ressourcen:Backup,Schedule,Restore,Config

Eine YAML-Manifestdatei mit den Definitionen für die oben genannten Kubernetes-Objekte befindet sich inArk source code. Laden Sie den Quellcode-Tarball herunter, der der zuvor heruntergeladenen Client-Release-Version entspricht, während Sie sich noch im Verzeichnis/tmpbefinden. In diesem Tutorial ist diesv0.10.0: 

wget https://github.com/heptio/velero/archive/v0.10.0.tar.gz

Extrahieren Sie nun den Tarball mittar (beachten Sie, dass der Dateiname je nach Release-Version unterschiedlich sein kann): 

tar -xvzf v0.10.0.tar.gz

Navigieren Sie nach dem Herunterladen in das Verzeichnisvelero-0.10.0: 

cd velero-0.10.0

Die oben aufgeführten vorausgesetzten Ressourcen befinden sich in der YAML-Datei vonexamples/common/00-prereqs.yaml. Wir erstellen diese Ressourcen in unserem Kubernetes-Cluster, indem wirkubectl apply verwenden und die Datei übergeben: 

kubectl apply -f examples/common/00-prereqs.yaml

Sie sollten die folgende Ausgabe sehen: 

Outputcustomresourcedefinition.apiextensions.k8s.io/backups.ark.heptio.com created
customresourcedefinition.apiextensions.k8s.io/schedules.ark.heptio.com created
customresourcedefinition.apiextensions.k8s.io/restores.ark.heptio.com created
customresourcedefinition.apiextensions.k8s.io/downloadrequests.ark.heptio.com created
customresourcedefinition.apiextensions.k8s.io/deletebackuprequests.ark.heptio.com created
customresourcedefinition.apiextensions.k8s.io/podvolumebackups.ark.heptio.com created
customresourcedefinition.apiextensions.k8s.io/podvolumerestores.ark.heptio.com created
customresourcedefinition.apiextensions.k8s.io/resticrepositories.ark.heptio.com created
customresourcedefinition.apiextensions.k8s.io/backupstoragelocations.ark.heptio.com created
customresourcedefinition.apiextensions.k8s.io/volumesnapshotlocations.ark.heptio.com created
namespace/heptio-ark created
serviceaccount/ark created
clusterrolebinding.rbac.authorization.k8s.io/ark created

Nachdem wir die erforderlichen Ark Kubernetes-Objekte in unserem Cluster erstellt haben, können wir dieArk DigitalOcean Plugin herunterladen und installieren, sodass wir DigitalOcean Spaces alsbackupStorageProvider (für Kubernetes-Objekte) und DigitalOcean verwenden können Blockspeicher alspersistentVolumeProvider (für dauerhafte Volumesicherungen).

Verlassen Sie das Verzeichnisvelero-0.10.0 und laden Sie die Versionv0.10.0 des Plugins herunter. Die Release-Versionen des Plugins finden Sie auf dem StackPointCloud DigitalOcean-Pluginreleases page. 

cd ..
wget https://github.com/StackPointCloud/ark-plugin-digitalocean/archive/v0.10.0.tar.gz

Extrahieren Sie nun den Tarball mittar (beachten Sie, dass der Dateiname je nach Release-Version unterschiedlich sein kann und mit.1 enden kann, wenn Sie den vorherigenv0.10.0.tar.gz-Tarball, der den Velero enthält, nicht gelöscht haben Client / Server-Quellcode): 

tar -xvzf v0.10.0.tar.gz.1

In das Plugin-Verzeichnis verschieben: 

cd ark-plugin-digitalocean-0.10.0

Wir speichern jetzt die Zugriffsschlüssel für unseren DigitalOcean Space als KubernetesSecret. Öffnen Sie zunächst die Dateiexamples/credentials-arkmit Ihrem bevorzugten Editor: 

nano examples/credentials-ark

Ersetzen Sie<AWS_ACCESS_KEY_ID> und<AWS_SECRET_ACCESS_KEY> durch Ihren Spaces-Zugriffsschlüssel und Ihren geheimen Schlüssel:

examples/credentials-ark

[default]
aws_access_key_id=your_spaces_access_key_here
aws_secret_access_key=your_spaces_secret_key_here

Speichern und schließen Sie die Datei.

Erstellen Sie nun dascloud-credentials-Geheimnis mitkubectl und fügen Sie Ihr persönliches API-Zugriffstoken mit dem Parameterdigitalocean_token ein: 

kubectl create secret generic cloud-credentials \
    --namespace heptio-ark \
    --from-file cloud=examples/credentials-ark \
    --from-literal digitalocean_token=your_personal_access_token

Sie sollten die folgende Ausgabe sehen: 

Outputsecret/cloud-credentials created

Um zu bestätigen, dass das Geheimnis voncloud-credentialserfolgreich erstellt wurde, können Sie es mitkubectldescribe verwenden: 

kubectl describe secrets/cloud-credentials --namespace heptio-ark

Die folgende Ausgabe sollte das Geheimnis voncloud-credentialsbeschreiben: 

OutputName:         cloud-credentials
Namespace:    heptio-ark
Labels:       
Annotations:  

Type:  Opaque

Data
====
cloud:               115 bytes
digitalocean_token:  64 bytes

Wir können nun mit dem Erstellen eines ArkBackupStorageLocation-Objekts mit dem Namendefault fortfahren, das das Objektspeicher-Backend des Plugins konfiguriert. Dazu bearbeiten wir eine YAML-Manifestdatei und erstellen dann das Objekt in unserem Kubernetes-Cluster.

Öffnen Sieexamples/05-ark-backupstoragelocation.yaml in Ihrem Lieblingseditor: 

nano examples/05-ark-backupstoragelocation.yaml

Geben Sie den Namen und die Region Ihres Space in die markierten Felder ein:

examples/05-ark-backupstoragelocation.yaml

. . .
---
apiVersion: ark.heptio.com/v1
kind: BackupStorageLocation
metadata:
  name: default
  namespace:  heptio-ark
spec:
  provider: aws
  objectStorage:
    bucket: space_name_here
  config:
    s3Url: https://space_region_here.digitaloceanspaces.com
    region: space_region_here

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Erstellen Sie das Objekt in Ihrem Cluster mitkubectl apply: 

kubectl apply -f examples/05-ark-backupstoragelocation.yaml

Sie sollten die folgende Ausgabe sehen: 

Outputbackupstoragelocation.ark.heptio.com/default created

Sie müssen diesen Vorgang nicht für dasVolumeSnapshotLocation-Objekt wiederholen, das das Blockspeicher-Backend konfiguriert. Es ist bereits mit den entsprechenden Parametern vorkonfiguriert. Um diese zu überprüfen, öffnen Sieexamples/06-ark-volumesnapshotlocation.yaml in Ihrem Editor: 

nano examples/06-ark-volumesnapshotlocation.yaml

examples/06-ark-volumesnapshotlocation.yaml

. . .
---
apiVersion: ark.heptio.com/v1
kind: VolumeSnapshotLocation
metadata:
  name: default
  namespace: heptio-ark
spec:
  provider: digitalocean-blockstore

Wenn Sie fertig sind, schließen Sie die Datei.

Erstellen Sie das Objekt in Ihrem Cluster mitkubectl apply: 

kubectl apply -f examples/06-ark-volumesnapshotlocation.yaml
Outputvolumesnapshotlocation.ark.heptio.com/default created

Zu diesem Zeitpunkt haben wir die Konfiguration des Ark-Servers abgeschlossen und können die Kubernetes-Bereitstellung erstellen, die in der Konfigurationsdatei vonexamples/10-deployment.yamlenthalten ist. Werfen wir einen kurzen Blick auf diese Datei: 

cat examples/10-deployment.yaml

Sie sollten den folgenden Text sehen:

examples/10-deployment.yaml

---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  namespace: heptio-ark
  name: ark
spec:
  replicas: 1
  template:
    metadata:
      labels:
        component: ark
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8085"
        prometheus.io/path: "/metrics"
    spec:
      restartPolicy: Always
      serviceAccountName: ark
      containers:
        - name: ark
          image: gcr.io/heptio-images/ark:latest
          command:
            - /ark
          args:
            - server
            - --default-volume-snapshot-locations=digitalocean-blockstore:default
          volumeMounts:
            - name: cloud-credentials
              mountPath: /credentials
            - name: plugins
              mountPath: /plugins
            - name: scratch
              mountPath: /scratch
          env:
            - name: AWS_SHARED_CREDENTIALS_FILE
              value: /credentials/cloud
            - name: ARK_SCRATCH_DIR
              value: /scratch
            - name: DIGITALOCEAN_TOKEN
              valueFrom:
                secretKeyRef:
                  key: digitalocean_token
                  name: cloud-credentials
      volumes:
        - name: cloud-credentials
          secret:
            secretName: cloud-credentials
        - name: plugins
          emptyDir: {}
        - name: scratch
          emptyDir: {}

Wir stellen hier fest, dass wir eine Bereitstellung mit dem Namenark erstellen, die aus einer einzelnen Replik desgcr.io/heptio-images/ark:latest-Containers besteht. Der Pod wird mit dem zuvor erstellten Geheimnis voncloud-credentialskonfiguriert.

Erstellen Sie die Bereitstellung mitkubectl apply: 

kubectl apply -f examples/10-deployment.yaml

Sie sollten die folgende Ausgabe sehen: 

Outputdeployment.apps/ark created

Wir können überprüfen, ob die Bereitstellung erfolgreich mitkubectl get im Namespaceheptio-ark erstellt wurde: 

kubectl get deployments --namespace=heptio-ark

Sie sollten die folgende Ausgabe sehen: 

OutputNAME   READY   UP-TO-DATE   AVAILABLE   AGE
ark    1/1     1            1           7s

Der Ark-Server-Pod wird möglicherweise erst ordnungsgemäß gestartet, nachdem Sie das Ark DigitalOcean-Plug-in installiert haben. Verwenden Sie zum Installieren desark-blockstore-digitalocean-Plugins den zuvor installiertenark-Client: 

ark plugin add quay.io/stackpoint/ark-blockstore-digitalocean:v0.10.0

Sie können diekubeconfig angeben, die mit dem--kubeconfig-Flag verwendet werden sollen. Wenn Sie dieses Flag nicht verwenden, überprüftark die UmgebungsvariableKUBECONFIGund greift dann auf die Standardeinstellung vonkubectl(~/.kube/config) zurück.

Zu diesem Zeitpunkt wird Ark ausgeführt, ist vollständig konfiguriert und kann Ihre Kubernetes-Clusterobjekte und persistenten Volumes in DigitalOcean Spaces und Block Storage sichern und wiederherstellen.

Im nächsten Abschnitt werden wir einen kurzen Test durchführen, um sicherzustellen, dass die Sicherungs- und Wiederherstellungsfunktionen wie erwartet funktionieren.

[[Schritt 3 - Testen der Sicherungs- und Wiederherstellungsprozedur] == Schritt 3 - Testen der Sicherungs- und Wiederherstellungsprozedur

Nachdem Ark erfolgreich installiert und konfiguriert wurde, können wir einen Test für die Nginx-Bereitstellung, das persistente Volume und den Service erstellen und einen Sicherungs- und Wiederherstellungs-Drill ausführen, um sicherzustellen, dass alles ordnungsgemäß funktioniert.

Dasark-plugin-digitalocean-Repository enthält ein Beispiel-Nginx-Manifest namensnginx-pv.yaml.

Öffnen Sie diese Datei mit einem Editor Ihrer Wahl: 

nano examples/nginx-pv.yaml

Sie sollten den folgenden Text sehen: 

Output---
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: nginx-logs
  namespace: nginx-example
  labels:
    app: nginx
spec:
  storageClassName: do-block-storage
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi

---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: nginx-example
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: nginx
    spec:
      volumes:
        - name: nginx-logs
          persistentVolumeClaim:
           claimName: nginx-logs
      containers:
      - image: nginx:1.7.9
        name: nginx
        ports:
        - containerPort: 80
        volumeMounts:
          - mountPath: "/var/log/nginx"
            name: nginx-logs
            readOnly: false

---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: nginx
  name: my-nginx
  namespace: nginx-example
spec:
  ports:
  - port: 80
    targetPort: 80
  selector:
    app: nginx
  type: LoadBalancer

In dieser Datei beachten wir Spezifikationen für:

  • Eine Nginx-Bereitstellung, die aus einer einzelnen Replik des Container-Images vonnginx:1.7.9besteht

  • Ein 5Gi Persistent Volume Claim (nginx-logs genannt) unter Verwendung der StorageClassdo-block-storage

  • ALoadBalancer Dienst, der Port80 verfügbar macht

Aktualisieren Sie die Image-Version vonnginxauf1.14.2: 

Output. . .
      containers:
      - image: nginx:1.14.2
        name: nginx
        ports:
        - containerPort: 80
        volumeMounts:
. . .

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Erstellen Sie die Objekte mitkubectl apply: 

kubectl apply -f examples/nginx-pv.yml

Sie sollten die folgende Ausgabe sehen: 

Outputnamespace/nginx-example created
persistentvolumeclaim/nginx-logs created
deployment.apps/nginx-deployment created
service/my-nginx created

Überprüfen Sie, ob die Bereitstellung erfolgreich war: 

kubectl get deployments --namespace=nginx-example

Sie sollten die folgende Ausgabe sehen: 

OutputNAME               DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   1         1         1            1           1h

SobaldAvailable 1 erreicht hat, rufen Sie die externe IP des Nginx Load Balancers mitkubectl get ab: 

kubectl get services --namespace=nginx-example

Sie sollten sowohl die internenCLUSTER-IP als auchEXTERNAL-IP für denmy-nginx Service sehen: 

OutputNAME       TYPE           CLUSTER-IP     EXTERNAL-IP       PORT(S)        AGE
my-nginx   LoadBalancer   10.32.27.0      203.0.113.0   80:30754/TCP   3m

Notieren Sie sich dieEXTERNAL-IP und navigieren Sie mit Ihrem Webbrowser dorthin.

Sie sollten die folgende NGINX-Begrüßungsseite sehen:

Nginx Welcome Page

Dies zeigt an, dass Ihre Nginx-Bereitstellung und Ihr Nginx-Dienst aktiv sind.

Bevor wir unser Katastrophenszenario simulieren, überprüfen wir zunächst die Nginx-Zugriffsprotokolle (die auf einem permanenten Volume gespeichert sind, das an den Nginx Pod angehängt ist):

Rufen Sie den Namen des Pods mitkubectl get ab: 

kubectl get pods --namespace nginx-example
OutputNAME                                READY     STATUS    RESTARTS   AGE
nginx-deployment-77d8f78fcb-zt4wr   1/1       Running   0          29m

Jetzt befindet sichexecim laufenden Nginx-Container, um eine Shell darin zu erhalten: 

kubectl exec -it nginx-deployment-77d8f78fcb-zt4wr --namespace nginx-example -- /bin/bash

Sobald Sie sich im Nginx-Container befinden, werdencatin den Nginx-Zugriffsprotokollen angezeigt: 

cat /var/log/nginx/access.log

Sie sollten einige Nginx-Zugriffseinträge sehen: 

Output10.244.17.1 - - [01/Oct/2018:21:47:01 +0000] "GET / HTTP/1.1" 200 612 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/203.0.113.11 Safari/537.36" "-"
10.244.17.1 - - [01/Oct/2018:21:47:01 +0000] "GET /favicon.ico HTTP/1.1" 404 570 "http://203.0.113.0/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/203.0.113.11 Safari/537.36" "-"

Notieren Sie sich diese (insbesondere die Zeitstempel), da wir sie verwenden, um den Erfolg des Wiederherstellungsvorgangs zu bestätigen.

Wir können jetzt die Sicherungsprozedur ausführen, um alle Kubernetes-Objekte vonnginxin Spaces zu kopieren und einen Snapshot des persistenten Volumes zu erstellen, das wir bei der Bereitstellung von Nginx erstellt haben.

Wir erstellen eine Sicherung mit dem Namennginx-backup mit dem Client vonark: 

ark backup create nginx-backup --selector app=nginx

Das--selector app=nginx weist den Ark-Server an, nur Kubernetes-Objekte mit dem Label Selectorapp=nginxzu sichern.

Sie sollten die folgende Ausgabe sehen: 

OutputBackup request "nginx-backup" submitted successfully.
Run `ark backup describe nginx-backup` for more details.

Das Ausführen vonark backup describe nginx-backup sollte nach einer kurzen Verzögerung die folgende Ausgabe liefern: 

OutputName:         nginx-backup
Namespace:    heptio-ark
Labels:       
Annotations:  

Phase:  Completed

Namespaces:
  Included:  *
  Excluded:  

Resources:
  Included:        *
  Excluded:        
  Cluster-scoped:  auto

Label selector:  app=nginx

Snapshot PVs:  auto

TTL:  720h0m0s

Hooks:  

Backup Format Version:  1

Started:    2018-09-26 00:14:30 -0400 EDT
Completed:  2018-09-26 00:14:34 -0400 EDT

Expiration:  2018-10-26 00:14:30 -0400 EDT

Validation errors:  

Persistent Volumes:
  pvc-e4862eac-c2d2-11e8-920b-92c754237aeb:
    Snapshot ID:        2eb66366-c2d3-11e8-963b-0a58ac14428b
    Type:               ext4
    Availability Zone:
    IOPS:

Diese Ausgabe zeigt an, dassnginx-backuperfolgreich abgeschlossen wurde.

Navigieren Sie in der DigitalOcean Cloud-Systemsteuerung zu dem Bereich, der Ihre Kubernetes-Sicherungsdateien enthält.

Sie sollten ein neues Verzeichnis mit dem Namennginx-backup sehen, das die Ark-Sicherungsdateien enthält.

Gehen Sie in der linken Navigationsleiste zuImages und dann zuSnapshots. Navigieren Sie innerhalb vonSnapshots zuVolumes. Sie sollten einen Schnappschuss sehen, der dem in der obigen Ausgabe aufgelisteten PVC entspricht.

Jetzt können wir den Wiederherstellungsvorgang testen.

Löschen wir zuerst den Namespace vonnginx-example. Dadurch wird alles im Namespace gelöscht, einschließlich Load Balancer und Persistent Volume: 

kubectl delete namespace nginx-example

Stellen Sie sicher, dass Sie am Load Balancer-Endpunkt nicht mehr auf Nginx zugreifen können und dass die Bereitstellung vonnginx-examplenicht mehr ausgeführt wird: 

kubectl get deployments --namespace=nginx-example
OutputNo resources found.

Wir können jetzt den Wiederherstellungsvorgang erneut mit dem Client vonarkdurchführen: 

ark restore create --from-backup nginx-backup

Hier verwenden wircreate, um ein ArkRestore-Objekt aus demnginx-backup-Objekt zu erstellen.

Sie sollten die folgende Ausgabe sehen: 

OutputRestore request "nginx-backup-20180926143828" submitted successfully.
Run `ark restore describe nginx-backup-20180926143828` for more details.

Überprüfen Sie den Status der wiederhergestellten Bereitstellung: 

kubectl get deployments --namespace=nginx-example
OutputNAME               DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   1         1         1            1           1m

Überprüfen Sie, ob ein beständiges Volume erstellt wurde: 

 kubectl get pvc --namespace=nginx-example
OutputNAME         STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS       AGE
nginx-logs   Bound     pvc-e4862eac-c2d2-11e8-920b-92c754237aeb   5Gi        RWO            do-block-storage   3m

Navigieren Sie erneut zur externen IP des Nginx-Dienstes, um zu bestätigen, dass Nginx aktiv ist.

Überprüfen Sie abschließend die Protokolle auf dem wiederhergestellten persistenten Volume, um sicherzustellen, dass der Protokollverlauf nach der Wiederherstellung beibehalten wurde.

Rufen Sie dazu erneut den Namen des Pods mitkubectl get ab: 

kubectl get pods --namespace nginx-example
OutputNAME                                READY     STATUS    RESTARTS   AGE
nginx-deployment-77d8f78fcb-zt4wr   1/1       Running   0          29m

Dann istexecdrin: 

kubectl exec -it nginx-deployment-77d8f78fcb-zt4wr --namespace nginx-example -- /bin/bash

Sobald Sie sich im Nginx-Container befinden, werdencatin den Nginx-Zugriffsprotokollen angezeigt: 

cat /var/log/nginx/access.log
Output10.244.17.1 - - [01/Oct/2018:21:47:01 +0000] "GET / HTTP/1.1" 200 612 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/203.0.113.11 Safari/537.36" "-"
10.244.17.1 - - [01/Oct/2018:21:47:01 +0000] "GET /favicon.ico HTTP/1.1" 404 570 "http://203.0.113.0/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/203.0.113.11 Safari/537.36" "-"

Es sollten dieselben Zugriffsversuche vor der Sicherung angezeigt werden (Zeitstempel beachten), die bestätigen, dass die Wiederherstellung des beständigen Volumes erfolgreich war. Beachten Sie, dass die Protokolle möglicherweise weitere Versuche enthalten, wenn Sie die Nginx-Zielseite nach der Wiederherstellung aufgerufen haben.

Zu diesem Zeitpunkt haben wir unsere Kubernetes-Objekte erfolgreich in DigitalOcean Spaces und unsere persistenten Volumes mit Block Storage Volume-Snapshots gesichert. Wir haben ein Katastrophenszenario simuliert und den Dienst für die Test-Nginx-Anwendung wiederhergestellt.

Fazit

In diesem Handbuch haben wir das Ark Kubernetes-Backup-Tool auf einem DigitalOcean-basierten Kubernetes-Cluster installiert und konfiguriert. Wir haben das Tool so konfiguriert, dass Kubernetes-Objekte in DigitalOcean Spaces und persistente Volumes mit Block Storage Volume Snapshots gesichert werden.

Ark kann auch verwendet werden, um regelmäßige Sicherungen Ihres Kubernetes-Clusters zu planen. Dazu können Sie den Befehlark schedule verwenden. Es kann auch zum Migrieren von Ressourcen von einem Cluster zu einem anderen verwendet werden. Weitere Informationen zu diesen beiden Anwendungsfällen finden Sie inofficial Ark documentation.

Weitere Informationen zu DigitalOcean Spaces finden Sie inofficial Spaces documentation. Weitere Informationen zu Blockspeicher-Volumes finden Sie inBlock Storage Volume documentation.

Dieses Tutorial baut auf der README-Datei inark-plugin-digitaloceanGitHub repo von StackPointCloud auf.

Related