TOC

Comment sauvegarder et restaurer un cluster Kubernetes sur DigitalOcean à l’aide de Heptio Ark

[.note] #Note: Le projet Ark a été renommé enVelero et a introduit plusieurs changements dans la v0.11.0. Ce guide sera bientôt mis à jour pour intégrer ces changements. Merci pour votre patience!
#

introduction

Heptio Ark est un outil de sauvegarde pratique pour les clusters Kubernetes qui compresse et sauvegarde les objets Kubernetes dans le stockage d'objets. Il prend également des instantanés des volumes persistants de votre cluster à l'aide des fonctionnalités d'instantané de stockage en bloc de votre fournisseur de cloud, puis peut restaurer les objets et les volumes persistants de votre cluster à un état antérieur.

LesDigitalOcean Ark Plugin de StackPointCloud vous permettent d'utiliser le stockage par blocs DigitalOcean pour créer un instantané de vos volumes persistants et des espaces pour sauvegarder vos objets Kubernetes. Lorsque vous exécutez un cluster Kubernetes sur DigitalOcean, cela vous permet de sauvegarder rapidement l’état de votre cluster et de le restaurer en cas de sinistre.

Dans ce didacticiel, nous allons configurer le client Ark sur une machine locale et déployer le serveur Ark dans notre cluster Kubernetes. Nous déploierons ensuite un exemple d'application Nginx utilisant un volume persistant pour la journalisation et simulons un scénario de récupération après sinistre.

Conditions préalables

Avant de commencer ce didacticiel, vous devez disposer des éléments suivants:

Sur votre ordinateur local:

  • L'outil de ligne de commandekubectl, configuré pour se connecter à votre cluster. Vous pouvez en savoir plus sur l'installation et la configuration dekubectl dans lesofficial Kubernetes documentation.

  • L'utilitaire de ligne de commandegit. Vous pouvez apprendre comment installergit dansGetting Started with Git.

Dans votre compte DigitalOcean:

  • Un clusterDigitalOcean Kubernetes ou un cluster Kubernetes (version1.7.5 ou ultérieure) sur les gouttelettes DigitalOcean

  • Un serveur DNS en cours d'exécution à l'intérieur de votre cluster. Si vous utilisez DigitalOcean Kubernetes, celui-ci s'exécute par défaut. Pour en savoir plus sur la configuration d'un service DNS Kubernetes, consultezCustomizing DNS Service dans la documentation officielle de Kuberentes.

  • Un espace DigitalOcean qui stockera vos objets Kubernetes sauvegardés. Pour savoir comment créer un espace, consultezthe Spaces product documentation.

  • Une paire de clés d’accès pour votre espace DigitalOcean. Pour savoir comment créer un ensemble de clés d'accès, consultezHow to Manage Administrative Access to Spaces.

  • Un jeton d'accès personnel à utiliser avec l'API DigitalOcean. Pour savoir comment créer un jeton d'accès personnel, consultezHow to Create a Personal Access Token.

Une fois que tout est configuré, vous êtes prêt à commencer avec ce guide.

[[step-1 -—- Installing-the-ark-client]] == Étape 1 - Installation du client Ark

L'outil de sauvegarde Heptio Ark se compose d'un client installé sur votre ordinateur local et d'un serveur qui s'exécute dans votre cluster Kubernetes. Pour commencer, nous allons installer le client Ark local.

Dans votre navigateur Web, accédez au dépôt Ark / Velero GitHubreleases page, recherchez la version correspondant à votre système d'exploitation et à l'architecture de votre système, puis copiez l'adresse du lien. Pour les besoins de ce guide, nous utiliserons un serveur Ubuntu 18.04 sur un processeur x86-64 (ou AMD64) comme notre machine locale, et la version de Arkv0.10.0.

[.note] #Note: Pour suivre ce guide, vous devez télécharger et installerv0.10.0 du client Ark.
#

Ensuite, à partir de la ligne de commande sur votre ordinateur local, accédez au répertoire temporaire/tmp et àcd dedans: 

cd /tmp

Utilisezwget et le lien que vous avez copié précédemment pour télécharger l'archive tar de la version: 

wget https://link_copied_from_release_page

Une fois le téléchargement terminé, extrayez l'archive tar à l'aide detar (notez que le nom de fichier peut différer en fonction de la version publiée et de votre système d'exploitation): 

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

Le répertoire/tmp doit maintenant contenir le binaireark extrait ainsi que l'archive tar que vous venez de télécharger.

Vérifiez que vous pouvez exécuter le clientark en exécutant le binaire: 

./ark --help

Vous devriez voir la sortie d'aide suivante: 

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

. . .

À ce stade, vous devez déplacer l'exécutableark hors du répertoire temporaire/tmp et l'ajouter à vosPATH. Pour l'ajouter à votrePATH sur un système Ubuntu, copiez-le simplement dans/usr/local/bin: 

sudo mv ark /usr/local/bin/ark

Vous êtes maintenant prêt à configurer le serveur Ark et à le déployer sur votre cluster Kubernetes.

[[step-2 -—- installation-and-configuration-the-ark-server]] == Étape 2 - Installation et configuration du serveur Ark

Avant de déployer Ark dans notre cluster Kubernetes, nous allons d’abord créer les objets prérequis d’Ark. Les conditions préalables d’Ark sont les suivantes:

  • Un espace de nomsheptio-ark

  • Le compte de serviceark

  • Règles de contrôle d'accès basé sur les rôles (RBAC) pour accorder des autorisations au compte de serviceark

  • Ressources personnalisées (CRD) pour les ressources spécifiques à l'Arche:Backup,Schedule,Restore,Config

Un fichier manifeste YAML contenant les définitions des objets Kubernetes ci-dessus se trouve dans le fichierArk source code. Tout en restant dans le répertoire/tmp, téléchargez l'archive tar du code source correspondant à la version du client que vous avez téléchargée précédemment. Dans ce didacticiel, voiciv0.10.0: 

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

Maintenant, extrayez l'archive tar à l'aide detar (notez que le nom du fichier peut différer selon la version): 

tar -xvzf v0.10.0.tar.gz

Une fois téléchargé, accédez au répertoirevelero-0.10.0: 

cd velero-0.10.0

Les ressources prérequises répertoriées ci-dessus se trouvent dans le fichier YAML deexamples/common/00-prereqs.yaml. Nous allons créer ces ressources dans notre cluster Kubernetes en utilisantkubectl apply et en transmettant le fichier: 

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

Vous devriez voir la sortie suivante: 

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

Maintenant que nous avons créé les objets Ark Kubernetes nécessaires dans notre cluster, nous pouvons télécharger et installer lesArk DigitalOcean Plugin, ce qui nous permettra d'utiliser les espaces DigitalOcean en tant quebackupStorageProvider (pour les objets Kubernetes) et DigitalOcean Bloquer le stockage en tant quepersistentVolumeProvider (pour les sauvegardes de volumes persistants).

Sortez du répertoirevelero-0.10.0 et téléchargez la versionv0.10.0 du plugin. Vous pouvez trouver les versions de version du plug-in sur le plug-in StackPointCloud DigitalOceanreleases page. 

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

Maintenant, extrayez l'archive tar à l'aide detar (notez que le nom de fichier peut différer selon la version de publication, et peut se terminer par un.1 si vous n'avez pas supprimé l'archive tarv0.10.0.tar.gz précédente qui contient le Velero code source client / serveur): 

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

Déplacez-vous dans le répertoire du plugin: 

cd ark-plugin-digitalocean-0.10.0

Nous allons maintenant enregistrer les clés d'accès de notre espace DigitalOcean en tant que KubernetesSecret. Tout d'abord, ouvrez le fichierexamples/credentials-ark en utilisant votre éditeur préféré: 

nano examples/credentials-ark

Remplacez<AWS_ACCESS_KEY_ID> et<AWS_SECRET_ACCESS_KEY> par votre clé d'accès Spaces et votre clé secrète:

examples/credentials-ark

[default]
aws_access_key_id=your_spaces_access_key_here
aws_secret_access_key=your_spaces_secret_key_here

Enregistrez et fermez le fichier.

Maintenant, créez le secretcloud-credentials à l'aide dekubectl, en insérant votre jeton d'accès personnel API à l'aide du paramètredigitalocean_token: 

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

Vous devriez voir la sortie suivante: 

Outputsecret/cloud-credentials created

Pour confirmer que le secretcloud-credentials a été créé avec succès, vous pouvez ledescribe en utilisantkubectl: 

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

Vous devriez voir la sortie suivante décrivant le secretcloud-credentials: 

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

Type:  Opaque

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

Nous pouvons maintenant passer à la création d'un objet ArkBackupStorageLocation nommédefault qui configurera le backend de stockage d'objets du plugin. Pour ce faire, nous allons éditer un fichier manifeste YAML, puis créer l'objet dans notre cluster Kubernetes.

Ouvrezexamples/05-ark-backupstoragelocation.yaml dans votre éditeur préféré: 

nano examples/05-ark-backupstoragelocation.yaml

Insérez le nom et la région de votre espace dans les champs en surbrillance:

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

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Créez l'objet dans votre cluster à l'aide dekubectl apply: 

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

Vous devriez voir la sortie suivante: 

Outputbackupstoragelocation.ark.heptio.com/default created

Vous n’avez pas besoin de répéter cette procédure pour l’objetVolumeSnapshotLocation, qui configure le backend de stockage de blocs. Il est déjà préconfiguré avec les paramètres appropriés. Pour les inspecter, ouvrezexamples/06-ark-volumesnapshotlocation.yaml dans votre éditeur: 

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

Lorsque vous avez terminé, fermez le fichier.

Créez l'objet dans votre cluster à l'aide dekubectl apply: 

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

À ce stade, nous avons terminé la configuration du serveur Ark et pouvons créer son déploiement Kubernetes, qui se trouve dans le fichier de configuration deexamples/10-deployment.yaml. Jetons un coup d’œil à ce fichier: 

cat examples/10-deployment.yaml

Vous devriez voir le texte suivant:

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: {}

Nous observons ici que nous créons un déploiement appeléark qui consiste en une réplique unique du conteneurgcr.io/heptio-images/ark:latest. Le pod est configuré à l'aide du secretcloud-credentials que nous avons créé précédemment.

Créez le déploiement à l'aide dekubectl apply: 

kubectl apply -f examples/10-deployment.yaml

Vous devriez voir la sortie suivante: 

Outputdeployment.apps/ark created

Nous pouvons vérifier que le déploiement a été créé avec succès en utilisantkubectl get sur l'espace de nomsheptio-ark: 

kubectl get deployments --namespace=heptio-ark

Vous devriez voir la sortie suivante: 

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

Le pod de serveur Ark peut ne pas démarrer correctement tant que vous n'avez pas installé le plug-in Ark DigitalOcean. Pour installer le pluginark-blockstore-digitalocean, utilisez le clientark que nous avons installé précédemment: 

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

Vous pouvez spécifier leskubeconfig à utiliser avec l'indicateur--kubeconfig. Si vous n’utilisez pas cet indicateur,ark vérifiera la variable d’environnementKUBECONFIG puis reviendra à la valeur par défaut dekubectl (~/.kube/config).

À ce stade, Ark est en cours d'exécution, entièrement configuré et prêt à sauvegarder et restaurer vos objets de cluster Kubernetes et vos volumes persistants dans des espaces DigitalOcean et dans le stockage en mode bloc.

Dans la section suivante, nous allons effectuer un test rapide pour nous assurer que les fonctionnalités de sauvegarde et de restauration fonctionnent comme prévu.

[[step-3 -—- testing-backup-and-restore-procedure]] == Étape 3 - Test de la procédure de sauvegarde et de restauration

Maintenant que nous avons correctement installé et configuré Ark, nous pouvons créer un test de déploiement, de volume persistant et de service Nginx et exécuter une analyse de sauvegarde et de restauration pour vérifier que tout fonctionne correctement.

Le référentielark-plugin-digitalocean contient un exemple de manifeste Nginx appelénginx-pv.yaml.

Ouvrez ce fichier en utilisant l'éditeur de votre choix: 

nano examples/nginx-pv.yaml

Vous devriez voir le texte suivant: 

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

Dans ce fichier, nous observons les spécifications pour:

  • Un déploiement Nginx constitué d'une seule réplique de l'image du conteneurnginx:1.7.9

  • Une revendication de volume persistant 5Gi (appeléenginx-logs), à l'aide de la StorageClassdo-block-storage

  • Un serviceLoadBalancer qui expose le port80

Mettez à jour la version d'image denginx vers1.14.2: 

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

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Créez les objets en utilisantkubectl apply: 

kubectl apply -f examples/nginx-pv.yml

Vous devriez voir la sortie suivante: 

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

Vérifiez que le déploiement a réussi: 

kubectl get deployments --namespace=nginx-example

Vous devriez voir la sortie suivante: 

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

Une fois queAvailable atteint 1, récupérez l'adresse IP externe de l'équilibreur de charge Nginx à l'aide dekubectl get: 

kubectl get services --namespace=nginx-example

Vous devriez voir lesCLUSTER-IP internes et lesEXTERNAL-IP pour le servicemy-nginx: 

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

Notez lesEXTERNAL-IP et accédez-y à l'aide de votre navigateur Web.

Vous devriez voir la page d’accueil NGINX suivante:

Nginx Welcome Page

Cela indique que votre déploiement et votre service Nginx sont opérationnels.

Avant de simuler notre scénario de sinistre, vérifions d’abord les journaux d’accès Nginx (stockés sur un volume persistant attaché au pod Nginx):

Récupérez le nom du pod à l'aide dekubectl get: 

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

Maintenant,exec dans le conteneur Nginx en cours d'exécution pour obtenir un shell à l'intérieur: 

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

Une fois à l'intérieur du conteneur Nginx,cat les journaux d'accès Nginx: 

cat /var/log/nginx/access.log

Vous devriez voir certaines entrées d’accès à Nginx: 

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" "-"

Notez-les (en particulier les horodatages), car nous les utiliserons pour confirmer le succès de la procédure de restauration.

Nous pouvons maintenant effectuer la procédure de sauvegarde pour copier tous les objets Kubernetes denginx dans Spaces et prendre un instantané du volume persistant que nous avons créé lors du déploiement de Nginx.

Nous allons créer une sauvegarde appeléenginx-backup à l'aide du clientark: 

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

Le--selector app=nginx indique au serveur Ark de ne sauvegarder que les objets Kubernetes avec le sélecteur d'étiquettesapp=nginx.

Vous devriez voir la sortie suivante: 

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

L'exécution deark backup describe nginx-backup doit fournir la sortie suivante après un court délai: 

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:

Cette sortie indique quenginx-backup s'est terminé avec succès.

Dans le panneau de configuration de DigitalOcean Cloud, accédez à l'espace contenant vos fichiers de sauvegarde Kubernetes.

Vous devriez voir un nouveau répertoire appelénginx-backup contenant les fichiers de sauvegarde Ark.

À l'aide de la barre de navigation de gauche, accédez àImages puis àSnapshots. Dans lesSnapshots, accédez àVolumes. Vous devriez voir un instantané correspondant au PVC indiqué dans la sortie ci-dessus.

Nous pouvons maintenant tester la procédure de restauration.

Supprimons d'abord l'espace de nomsnginx-example. Cela supprimera tout dans l'espace de noms, y compris l'équilibreur de charge et le volume persistant: 

kubectl delete namespace nginx-example

Vérifiez que vous ne pouvez plus accéder à Nginx au point de terminaison Load Balancer et que le déploiement denginx-example n'est plus en cours d'exécution: 

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

Nous pouvons maintenant effectuer la procédure de restauration, à nouveau en utilisant le clientark: 

ark restore create --from-backup nginx-backup

Ici, nous utilisonscreate pour créer un objet ArkRestore à partir de l'objetnginx-backup.

Vous devriez voir la sortie suivante: 

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

Vérifiez l'état du déploiement restauré: 

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

Vérifiez la création d'un volume persistant: 

 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

Accédez de nouveau à l'adresse IP externe du service Nginx pour vérifier que Nginx est opérationnel.

Enfin, vérifiez les journaux sur le volume persistant restauré pour vous assurer que l'historique des journaux a été préservé après la restauration.

Pour ce faire, récupérez à nouveau le nom du pod en utilisantkubectl get: 

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

Puisexec dedans: 

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

Une fois à l'intérieur du conteneur Nginx,cat les journaux d'accès Nginx: 

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" "-"

Vous devriez voir les mêmes tentatives d'accès avant la sauvegarde (notez les horodatages), confirmant que la restauration du volume persistant a réussi. Notez qu'il peut y avoir des tentatives supplémentaires dans les journaux si vous avez visité la page de destination Nginx après avoir effectué la restauration.

À ce stade, nous avons sauvegardé avec succès nos objets Kubernetes dans des espaces DigitalOcean, ainsi que nos volumes persistants à l'aide d'instantanés de volume de stockage de bloc. Nous avons simulé un scénario de sinistre et restauré le service dans l'application de test Nginx.

Conclusion

Dans ce guide, nous avons installé et configuré l'outil de sauvegarde Ark Kubernetes sur un cluster Kubernetes basé sur DigitalOcean. Nous avons configuré cet outil pour sauvegarder les objets Kubernetes dans des espaces DigitalOcean et pour sauvegarder des volumes persistants à l'aide d'instantanés de volume de stockage en mode bloc.

Ark peut également être utilisé pour planifier des sauvegardes régulières de votre cluster Kubernetes. Pour ce faire, vous pouvez utiliser la commandeark schedule. Il peut également être utilisé pour migrer des ressources d'un cluster à un autre. Pour en savoir plus sur ces deux cas d'utilisation, consultez lesofficial Ark documentation.

Pour en savoir plus sur les espaces DigitalOcean, consultez lesofficial Spaces documentation. Pour en savoir plus sur les volumes de stockage en bloc, consultez lesBlock Storage Volume documentation.

Ce tutoriel s'appuie sur le fichier README trouvé dans lesark-plugin-digitaloceanGitHub repo de StackPointCloud.

Related