Sauvegarder et restaurer des clusters

Cette page explique comment sauvegarder et restaurer le magasin etcd pour un cluster. Elle fournit également un script que vous pouvez utiliser pour sauvegarder automatiquement le magasin etcd d'un cluster.

Vous pouvez créer un fichier de sauvegarde aux fins d'une récupération en cas de sinistres prévus qui pourraient détruire les données etcd de votre cluster. Stockez le fichier de sauvegarde dans un emplacement hors du cluster et indépendant du fonctionnement du cluster.

Avertissement : L'utilisation d'un fichier de sauvegarde pour restaurer vos données etcd est un dernier recours. Nous vous déconseillons d'effectuer une restauration à partir d'un fichier de sauvegarde, sauf si le cluster est complètement endommagé. Contactez l'assistance Google si vous avez besoin d'aide pour choisir la meilleure solution.

Limites

• Cette procédure ne sauvegarde pas les données spécifiques à l'application.

• Cette procédure ne sauvegarde pas vos objets PersistentVolume.

• Les charges de travail planifiées après la création d'une sauvegarde donnée ne sont pas restaurées avec cette sauvegarde.

• Vous ne pouvez pas restaurer un cluster après une mise à niveau échouée.

• Cette procédure n'a pas pour objectif de restaurer un cluster supprimé.

Déterminer l'image de conteneur pour les pods etcd d'un cluster d'utilisateur

Pour certaines étapes de ce guide, vous devez connaître l'image de conteneur des pods etcd de votre cluster utilisateur. Procédez comme suit pour déterminer l'image du conteneur :

1. Affichez le pod kube-etcd-0 :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG get pod kube-etcd-0 \
       --namespace USER_CLUSTER_NAME --output yaml
   

2. Vous pouvez voir l'image du conteneur dans le résultat. Exemple :

   apiVersion: v1
   kind: Pod
   ...
   spec:
     containers:
       ...
       image: gcr.io/gke-on-prem-release/etcd:v3.3.19-0-gke.0
   

3. Notez l'image du conteneur pour référence ultérieure. Ce guide utilise l'espace réservé ETCD_CONTAINER_IMAGE pour faire référence à cette image.

Sauvegarder un cluster d'utilisateur

Une sauvegarde de cluster d'utilisateur est un instantané du magasin etcd du cluster d'utilisateur. Le magasin etcd contient tous les objets Kubernetes et les objets personnalisés requis pour gérer l'état du cluster. L'instantané contient les données requises pour recréer les composants et les charges de travail du cluster.

Pour créer un instantané du magasin etcd, procédez comme suit :

1. Ouvrez une interface système dans le conteneur kube-etcd :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG exec -it \
      kube-etcd-0 --container kube-etcd --namespace USER_CLUSTER_NAME \
      -- bin/sh
   

   où :

   • ADMIN_CLUSTER_KUBECONFIG est le fichier kubeconfig du cluster d'administrateur.
   • USER_CLUSTER_NAME est le nom du cluster d'utilisateur.

2. Dans votre interface système, dans le répertoire racine, créez une sauvegarde nommée snapshot.db :

   ETCDCTL_API=3 etcdctl \
      --endpoints=https://127.0.0.1:2379 \
      --cacert=/etcd.local.config/certificates/etcdCA.crt \
      --cert=/etcd.local.config/certificates/etcd.crt \
      --key=/etcd.local.config/certificates/etcd.key \
      snapshot save snapshot.db
   

3. Dans votre interface système, saisissez exit pour quitter l'interface système.

4. Copiez snapshot.db du conteneur kube-etcd vers le répertoire actuel :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG cp \
      USER_CLUSTER_NAME/kube-etcd-0:snapshot.db \
      --container kube-etcd snapshot.db
   

Restaurer un cluster d'utilisateur à partir d'une sauvegarde (standard)

Avant d'utiliser un fichier de sauvegarde pour restaurer le magasin etcd de votre cluster d'utilisateur, diagnostiquez votre cluster et résolvez les problèmes existants. Utiliser une sauvegarde pour restaurer un cluster problématique peut recréer, voire exacerber les problèmes. Contactez l'équipe d'assistance GKE On-Prem pour obtenir de l'aide sur la restauration de vos clusters.

Les instructions suivantes expliquent comment utiliser un fichier de sauvegarde pour restaurer un cluster d'utilisateur si les données etcd du cluster sont endommagées et que le pod etcd du cluster d'utilisateur tourne en boucle.

Vous pouvez restaurer les données etcd en déployant un pod utilitaire qui écrase les données endommagées avec la sauvegarde. Le serveur d'API du cluster d'administrateur doit être en cours d'exécution et le planificateur du cluster doit pouvoir planifier de nouveaux pods.

1. Copiez le fichier manifeste de pod suivant dans un fichier nommé etcd-utility.yaml. Remplacez ces espaces réservés par des valeurs :

   • NODE_NAME est le nœud sur lequel le pod kube-etcd-0 est exécuté.

   • ADMIN_CLUSTER_KUBECONFIG est le fichier kubeconfig du cluster d'administrateur.

   • USER_CLUSTER_NAME est le nom du cluster d'utilisateur.

   • ETCD_CONTAINER_IMAGE est l'image de conteneur de votre pod kube-etcd-0.

   apiVersion: v1
   kind: Pod
   metadata:
     name: etcd-utility-0
     namespace: USER_CLUSTER_NAME
   spec:
     containers:
     - command: ["/bin/sh"]
       args: ["-ec", "while :; do echo '.'; sleep 5 ; done"]
       image: ETCD_CONTAINER_IMAGE
       name: etcd-utility
       volumeMounts:
       - mountPath: /var/lib/etcd
         name: data
       - mountPath: /etcd.local.config/certificates
         name: etcd-certs
     nodeSelector:
       kubernetes.googleapis.com/cluster-name: USER_CLUSTER_NAME
       kubernetes.io/hostname: NODE_NAME
     tolerations:
     - effect: NoExecute
       key: node.kubernetes.io/not-ready
       operator: Exists
       tolerationSeconds: 300
     - effect: NoExecute
       key: node.kubernetes.io/unreachable
       operator: Exists
       tolerationSeconds: 300
     - effect: NoSchedule
       key: node.kubernetes.io/unschedulable
       operator: Exists
     volumes:
     - name: data
       persistentVolumeClaim:
         claimName: data-kube-etcd-0
     - name: etcd-certs
       secret:
         defaultMode: 420
         secretName: kube-etcd-certs
   

2. Déployez le pod utilitaire :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
      create -f etcd-utility.yaml --namespace USER_CLUSTER_NAME
   

3. Copiez snapshot.db du répertoire actuel vers le répertoire racine du pod utilitaire :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG cp snapshot.db \
      USER_CLUSTER_NAME/etcd-utility-0:snapshot.db --container etcd-utility
   

4. Obtenez une interface système dans le conteneur etcd-utility :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG exec it \
      etcd-utility-0 --container etcd-utility --namespace USER_CLUSTER_NAME \
      -- bin/sh
   

5. Dans votre interface système, dans le répertoire racine, exécutez la commande suivante pour créer un dossier contenant la sauvegarde :

   ETCDCTL_API=3 etcdctl \
      --endpoints=https://127.0.0.1:2379 \
      --cacert=/etcd.local.config/certificates/etcdCA.crt \
      --cert=/etcd.local.config/certificates/etcd.crt \
      --key=/etcd.local.config/certificates/etcd.key \
      snapshot restore snapshot.db
   

6. Dans votre interface système, supprimez les anciennes données etcd :

   rm -r var/lib/etcd/*
   

7. Dans votre interface système, copiez les données etcd restaurées vers leur emplacement permanent :

   cp -r default.etcd/* var/lib/etcd/
   

8. Dans votre interface système, saisissez exit pour quitter l'interface système.

9. Supprimez le pod etcd qui plante :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
      delete pod kube-etcd-0 --namespace USER_CLUSTER_NAME
   

10. Vérifiez que le pod etcd ne plante plus.

11. Supprimez le pod utilitaire :

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
       delete pod etcd-utility-0 --namespace USER_CLUSTER_NAME

12. Supprimez etcd-utility.yaml du répertoire actuel :

    rm etcd-utility.yaml
    

Restaurer un cluster d'utilisateur à partir d'une sauvegarde (haute disponibilité)

Cette section explique comment restaurer les données etcd pour un cluster d'utilisateur haute disponibilité.

Pour un cluster d'utilisateur haute disponibilité, trois nœuds du cluster d'administrateur servent de plans de contrôle pour le cluster d'utilisateur. Chacun de ces nœuds exécute un pod etcd qui gère les données etcd sur un volume de stockage.

Si deux des pods etcd sont opérationnels et que les données sur les volumes de stockage associés sont intactes, il n'est pas nécessaire d'utiliser un fichier de sauvegarde. En effet, vous aurez toujours un quorum etcd.

Dans les rares cas où deux des volumes de stockage etcd contiennent des données corrompues, vous devez utiliser un fichier de sauvegarde pour les restaurer.

Pour suivre les étapes de cette section, vous devez déjà avoir créé un fichier snapshot.db, comme décrit dans Sauvegarder un cluster d'utilisateur.

Répertorier vos pods et nœuds etcd

1. Répertoriez les pods etcd qui gèrent le magasin etcd pour votre cluster d'utilisateur. Ces pods s'exécutent dans le cluster d'administrateur :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG get pods --namespace USER_CLUSTER_NAME \
       --output wide | grep kube-etcd
   

   Le résultat affiche les pods etcd et les nœuds sur lesquels ils s'exécutent. Les nœuds affichés dans le résultat sont des nœuds du cluster d'administrateur servant de plans de contrôle pour votre cluster d'utilisateur :

   NAME              ...   NODE
   kube-etcd-0       ...   node-xxx
   kube-etcd-1       ...   node-yyy
   kube-etcd-2       ...   node-zzz
   

2. Notez les noms des pods et des nœuds du plan de contrôle pour les utiliser plus tard.

   Notez que chaque pod etcd est nommé kube-etcd et est accompagné d'un numéro. Ce numéro est appelé numéro de membre du pod. Il identifie le pod comme étant un membre particulier du cluster etcd qui contient les données d'objet de votre cluster d'utilisateur. Ce guide utilise l'espace réservé MEMBER_NUMBER pour faire référence au numéro de membre du pod etcd.

   Notez également que chaque pod de votre cluster etcd s'exécute sur son propre nœud.

Préparer le déploiement des pods utilitaires

1. Enregistrez un fichier manifeste pour le PodDisruptionBudget (PDB) du serveur d'API Kubernetes du cluster d'utilisateur. Supprimez ensuite le PDB.

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG get pdb --namespace USER_CLUSTER_NAME \
      kube-apiserver-pdb --output yaml > kube-apiserver-pdb.yaml
   
   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG delete pdb --namespace USER_CLUSTER_NAME \
      kube-apiserver-pdb
   

2. Arrêtez le serveur d'API Kubernetes et le déploiement de maintenance etcd. Cela garantit qu'aucun composant n'utilisera etcd lors de la restauration :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG --namespace USER_CLUSTER_NAME \
      scale --replicas 0 statefulset kube-apiserver
   
   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG --namespace USER_CLUSTER_NAME \
      scale --replicas 0 deployment gke-master-etcd-maintenance
   

3. Rappelez le nom de l'image de conteneur pour vos pods etcd.

Déployer les pods utilitaires

Suivez la procédure décrite dans cette section pour chacun de vos pods etcd.

1. Rappelez le nom du pod etcd et le nom du nœud sur lequel le pod s'exécute.

2. Enregistrez le fichier manifeste de pod suivant dans le répertoire actuel dans un fichier nommé etcd-utility-MEMBER_NUMBER.yaml :

   apiVersion: v1
   kind: Pod
   metadata:
     name: etcd-utility-MEMBER_NUMBER
     namespace: USER_CLUSTER_NAME
   spec:
     containers:
     - command: ["/bin/sh"]
       args: ["-ec", "while :; do echo '.'; sleep 5 ; done"]
       image: ETCD_CONTAINER_IMAGE
       name: etcd-utility
       volumeMounts:
       - mountPath: /var/lib/etcd
         name: data
       - mountPath: /etcd.local.config/certificates
         name: etcd-certs
     nodeSelector:
       kubernetes.googleapis.com/cluster-name: USER_CLUSTER_NAME
       kubernetes.io/hostname: NODE_NAME
     tolerations:
     - effect: NoExecute
       key: node.kubernetes.io/not-ready
       operator: Exists
       tolerationSeconds: 300
     - effect: NoExecute
       key: node.kubernetes.io/unreachable
       operator: Exists
       tolerationSeconds: 300
     - effect: NoSchedule
       key: node.kubernetes.io/unschedulable
       operator: Exists
     volumes:
     - name: data
       persistentVolumeClaim:
         claimName: data-kube-etcd-MEMBER_NUMBER
     - name: etcd-certs
       secret:
         defaultMode: 420
         secretName: kube-etcd-certs
   

   Le fichier manifeste précédent décrit un pod utilitaire que vous exécutez temporairement pour restaurer les données etcd.

3. Créez le pod utilitaire dans votre cluster d'administrateur :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG apply -f etcd-utility-MEMBER_NUMBER.yaml
   

4. Copiez votre fichier de sauvegarde snapshot.db dans le répertoire racine de votre pod utilitaire :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG cp snapshot.db \
      USER_CLUSTER_NAME/etcd-utility-MEMBER_NUMBER:snapshot.db
   

5. Ajoutez une interface système dans le conteneur etcd-utility du pod utilitaire :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG exec -it --namespace USER_CLUSTER_NAME \
      etcd-utility-MEMBER_NUMBER --container etcd-utility -- bin/sh
   

6. Dans votre interface système, dans le répertoire racine, utilisez snapshot.db pour restaurer les données etcd :

   ETCDCTL_API=3 etcdctl \
       --endpoints=https://127.0.0.1:2379 \
       --cacert=/etcd.local.config/certificates/etcdCA.crt \
       --cert=/etcd.local.config/certificates/etcd.crt \
       --key=/etcd.local.config/certificates/etcd.key \
       --name=kube-etcd-MEMBER_NUMBER \
       --initial-cluster=kube-etcd-0=https://kube-etcd-0.kube-etcd:2380,kube-etcd-1=https://kube-etcd-1.kube-etcd:2380,kube-etcd-2=https://kube-etcd-2.kube-etcd:2380 \
       --initial-cluster-token=etcd-cluster-1 \
       --initial-advertise-peer-urls=https://kube-etcd-MEMBER_NUMBER.kube-etcd:2380 \
       snapshot restore snapshot.db
   

   La commande précédente a stocké des données etcd dans le répertoire /kube-etcd-MEMBER_NUMBER.etcd.

7. Dans votre interface système, supprimez les anciennes données etcd :

   rm -r var/lib/etcd/*
   

8. Dans votre interface système, copiez les données etcd restaurées vers leur emplacement permanent :

   cp -r kube-etcd-MEMBER_NUMBER.etcd/* var/lib/etcd/
   

9. Dans votre interface système, supprimez le répertoire temporaire etcd et le fichier de sauvegarde :

   rm -R kube-etcd-MEMBER_NUMBER.etcd/
   rm snapshot.db
   

10. Dans votre interface système, saisissez exit pour quitter l'interface système.

11. Supprimez le pod utilitaire :

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG delete pod \
        --namespace USER_CLUSTER_NAME etcd-utility-MEMBER_NUMBER
    

Redémarrer des composants

Maintenant que vous avez déployé et supprimé vos pods utilitaires, vous devez redémarrer certains composants du cluster.

1. Redémarrez les pods dans le StatefulSet kube-etcd :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG restart rollout statefulset \
       --namespace USER_CLUSTER_NAME kube-etcd
   

2. Démarrez les serveurs d'API Kubernetes pour votre cluster d'utilisateur :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG scale statefulset --replicas 3 \
      --namespace USER_CLUSTER_NAME kube-apiserver
   

3. Démarrez le déploiement de maintenance etcd pour votre cluster d'utilisateur :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG scale deployment --replicas 1 \
       --namespace=USER_CLUSTER_NAME  gke-master-etcd-maintenance
   

4. Restaurez le PDB du serveur d'API Kubernetes :

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG apply -f kube-apiserver-pdb.yaml
   

Sauvegardes de clusters d'administrateur

Une sauvegarde de cluster d'administrateur contient les éléments suivants :

• Un instantané du magasin etcd du cluster d'administrateur.
• Les secrets du plan de contrôle d'administrateur, qui sont requis pour l'authentification dans les clusters d'administrateur et d'utilisateur.

Avant de créer une sauvegarde de cluster d'administrateur, procédez comme suit :

1. Recherchez l'adresse IP externe du cluster d'administrateur, qui est utilisée pour se connecter en SSH au plan de contrôle du cluster d'administrateur :

   kubectl --kubeconfig [ADMIN_KUBECONFIG] get nodes -n kube-system -o wide | grep master

   où [ADMIN_CLUSTER_KUBECONFIG] est le fichier kubeconfig du cluster d'administrateur.

2. Créez une clé SSH appelée vsphere_tmp à partir de la clé privée du cluster d'administrateur.

   Vous trouverez la clé privée dans les secrets du cluster d'administrateur :

   kubectl --kubeconfig [ADMIN_KUBECONFIG] get secrets sshkeys -n kube-system -o yaml

   Dans le résultat de la commande, vous trouverez la clé privée dans le champ vsphere_tmp.

   Copiez la clé privée dans vsphere_tmp :

   echo "[PRIVATE_KEY]" | base64 -d > vsphere_tmp; chmod 600 vsphere_tmp

3. Vérifiez que vous pouvez obtenir une interface système dans le plan de contrôle administrateur à l'aide de cette clé privée :

   ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
   

4. Quittez le conteneur :

   exit

Sauvegarder le magasin etcd d'un cluster d'administrateur

Pour sauvegarder le magasin etcd du cluster d'administrateur :

1. Obtenez le nom du pod etcd :

   kubectl --kubeconfig [ADMIN_KUBECONFIG] get pods \
       -n kube-system -l component=etcd,tier=control-plane -ojsonpath='{$.items[*].metadata.name}{"\n"}'

2. Obtenez une interface système dans le conteneur kube-etcd du pod :

   kubectl --kubeconfig [ADMIN_KUBECONFIG]  exec -it \
       -n kube-system [ADMIN_ETCD_POD] -- bin/sh

   où [ADMIN_ETCD_POD] est le nom du pod etcd.

3. Depuis l'interface système, utilisez etcdctl pour créer une sauvegarde nommée snapshot.db dans le répertoire local :

   ETCDCTL_API=3 etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt \
       --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt \
       --key=/etc/kubernetes/pki/etcd/healthcheck-client.key snapshot save snapshot.db
   

4. Quittez le conteneur :

   exit

5. Copiez la sauvegarde hors du conteneur kube-etcd à l'aide de kubectl cp :

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] cp \
   kube-system/[ADMIN_ETCD_POD]:snapshot.db [RELATIVE_DIRECTORY]
   

   où [RELATIVE_DIRECTORY] est un chemin d'accès où vous souhaitez stocker votre sauvegarde.

Restaurer un cluster d'administrateur

La procédure suivante recrée un cluster d'administrateur sauvegardé et tous les plans de contrôle utilisateur qu'il gérait au moment de la création de son instantané etcd.

Remarque : Le cluster d'utilisateur peut encore continuer à exécuter ses charges de travail même si le plan de contrôle utilisateur est hors service. Toutefois, si un plan de contrôle utilisateur est hors service, il ne peut pas planifier de charges de travail nouvelles ou mises à jour ou gérer d'autres défaillances de cluster.

1. Exécutez scp pour copier snapshot.db dans le plan de contrôle administrateur :

   sudo scp -i vsphere_tmp snapshot.db ubuntu@[EXTERNAL_IP]:

   où [EXTERNAL_IP] est l'adresse IP externe du plan de contrôle administrateur, que vous avez collectée précédemment.

2. Obtenez une interface système dans le plan de contrôle administrateur :

   sudo ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
   

3. Copiez snapshot.db/ vers /mnt :

   sudo cp snapshot.db /mnt/

4. Créez un répertoire temporaire, tel que backup :

   Remarque : Vous n'avez pas besoin d'effectuer cette opération s'il existe déjà un dossier de sauvegarde contenant les secrets.

   mkdir backup

5. Quittez le plan de contrôle administrateur :

   exit

6. Copiez les certificats dans backup/ :

   sudo scp -r -i vsphere_tmp [BACKUP_CERT_FILE] ubuntu@[EXTERNAL_IP]:backup/

7. Obtenez une interface système dans le nœud du plan de contrôle administrateur :

   ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
   

   où [EXTERNAL_IP] est l'adresse IP externe du plan de contrôle administrateur, que vous avez collectée précédemment.

8. Exécutez kubeadm reset. Cela interrompt tout ce qui est en cours d'exécution dans le cluster d'administrateur, supprime toutes les données etcd, ainsi que les secrets dans /etc/kubernetes/pki/ :

   sudo kubeadm reset --ignore-preflight-errors=all

9. Copiez les secrets de sauvegarde dans /etc/kubernetes/pki/ :

   sudo cp -r backup/* /etc/kubernetes/pki/

10. Exécutez etcdctl restore avec Docker :

    sudo docker run --rm \
    -v '/mnt:/backup' \
    -v '/var/lib/etcd:/var/lib/etcd' --env ETCDCTL_API=3 'k8s.gcr.io/etcd-amd64:3.1.12' /bin/sh -c "etcdctl snapshot restore '/backup/snapshot.db'; mv /default.etcd/member/ /var/lib/etcd/"

11. Exécutez kubeadm init. Cette opération réutilise tous les secrets de sauvegarde et redémarre etcd avec l'instantané restauré :

    sudo kubeadm init --config /etc/kubernetes/kubeadm_config.yaml --ignore-preflight-errors=DirAvailable--var-lib-etcd

12. Quittez le plan de contrôle administrateur :

    exit

13. Copiez le fichier kubeconfig nouvellement généré hors du nœud administrateur :

    sudo scp -i vsphere_tmp ubuntu@[EXTERNAL_IP]:[HOME]/.kube/config kubeconfig

    où :

    • [EXTERNAL_IP] est l'adresse IP externe du plan de contrôle administrateur ;
    • [HOME] est le répertoire d'accueil du nœud d'administrateur.

    Vous pouvez maintenant utiliser ce nouveau fichier kubeconfig pour accéder au cluster restauré.

Sauvegarder les secrets d'un cluster d'administrateur

Pour sauvegarder les secrets du plan de contrôle administrateur :

1. Obtenez une interface système dans le nœud du plan de contrôle administrateur :

   ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
   

   où [EXTERNAL_IP] est l'adresse IP externe du plan de contrôle administrateur, que vous avez collectée précédemment.

2. Créez un répertoire de sauvegarde local. Cette phase est facultative, mais vivement recommandée. Vous devez modifier les autorisations des secrets de sauvegarde pour les copier hors du nœud) :

   mkdir backup

3. Copiez localement les secrets vers le répertoire de sauvegarde local :

   sudo cp -r /etc/kubernetes/pki/* backup/

4. Modifiez les autorisations des secrets de sauvegarde :

   sudo chmod -R +rw backup/

5. Quittez le conteneur :

   exit

6. Exécutez scp pour copier le dossier de sauvegarde hors du nœud de plan de contrôle administrateur :

   sudo scp -r -i vsphere_tmp  ubuntu@[EXTERNAL_IP]:backup/ [RELATIVE_DIRECTORY]
   

   où [RELATIVE_DIRECTORY] est un chemin d'accès où vous souhaitez stocker votre sauvegarde.

Script de sauvegarde

Vous pouvez utiliser le script fourni ici comme exemple pour la sauvegarde automatique des clusters. Notez toutefois que le script suivant n'est pas compatible et ne doit être utilisé qu'à titre de référence pour écrire un script avancé qui soit plus fiable et plus complet. Avant d'exécuter le script, renseignez les valeurs des cinq variables figurant au début du script :

• Définissez BACKUP_DIR sur le chemin d'accès où vous souhaitez stocker les sauvegardes de cluster d'administrateur et d'utilisateur. Ce chemin d'accès ne doit pas déjà exister.
• Définissez ADMIN_CLUSTER_KUBECONFIG sur le chemin d'accès du fichier kubeconfig du cluster d'administrateur.
• Définissez USER_CLUSTER_NAMESPACE sur le nom de votre cluster d'utilisateur. Le nom de votre cluster d'utilisateur est un espace de noms dans le cluster d'administrateur.
• Définissez EXTERNAL_IP sur l'adresse IP virtuelle que vous avez réservée pour le service de plan de contrôle administrateur.
• Définissez SSH_PRIVATE_KEY sur le chemin d'accès de la clé SSH que vous avez créée lors de la configuration de votre poste de travail administrateur.
• Si vous utilisez un réseau privé, définissez JUMP_IP sur l'adresse IP du serveur intermédiaire de votre réseau.

#!/usr/bin/env bash

# Automates manual steps for taking backups of user and admin clusters.
# Fill in the variables below before running the script.

BACKUP_DIR=""                       # path to store user and admin cluster backups
ADMIN_CLUSTER_KUBECONFIG=""         # path to admin cluster kubeconfig
USER_CLUSTER_NAMESPACE=""           # user cluster namespace
EXTERNAL_IP=""                      # admin control plane node external ip - follow steps in documentation
SSH_PRIVATE_KEY=""                  # path to vsphere_tmp ssh private key - follow steps in documentation
JUMP_IP=""                          # network jump server IP - leave empty string if not using private network.

mkdir -p $BACKUP_DIR
mkdir $BACKUP_DIR/pki

# USER CLUSTER BACKUP

# Snapshot user cluster etcd
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} exec -it -n ${USER_CLUSTER_NAMESPACE} kube-etcd-0 -c kube-etcd -- /bin/sh -ec "export ETCDCTL_API=3; etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etcd.local.config/certificates/etcdCA.crt --cert=/etcd.local.config/certificates/etcd.crt --key=/etcd.local.config/certificates/etcd.key snapshot save ${USER_CLUSTER_NAMESPACE}_snapshot.db"
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} cp ${USER_CLUSTER_NAMESPACE}/kube-etcd-0:${USER_CLUSTER_NAMESPACE}_snapshot.db $BACKUP_DIR/user-cluster_${USER_CLUSTER_NAMESPACE}_snapshot.db

# ADMIN CLUSTER BACKUP

# Set up ssh options
SSH_OPTS=(-oStrictHostKeyChecking=no -i ${SSH_PRIVATE_KEY})
if [ "${JUMP_IP}" != "" ]; then
    SSH_OPTS+=(-oProxyCommand="ssh -oStrictHostKeyChecking=no -i ${SSH_PRIVATE_KEY} -W %h:%p ubuntu@${JUMP_IP}")
fi

# Copy admin certs
ssh "${SSH_OPTS[@]}" ubuntu@${EXTERNAL_IP} 'sudo chmod -R +rw /etc/kubernetes/pki/*'
scp -r "${SSH_OPTS[@]}" ubuntu@${EXTERNAL_IP}:/etc/kubernetes/pki/* ${BACKUP_DIR}/pki/

# Snapshot admin cluster etcd
admin_etcd=$(kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} get pods -n kube-system -l component=etcd,tier=control-plane -ojsonpath='{$.items[*].metadata.name}{"\n"}')
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} exec -it -n kube-system ${admin_etcd} -- /bin/sh -ec "export ETCDCTL_API=3; etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt --key=/etc/kubernetes/pki/etcd/healthcheck-client.key snapshot save admin_snapshot.db"
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} cp -n kube-system ${admin_etcd}:admin_snapshot.db $BACKUP_DIR/admin-cluster_snapshot.db

Dépannage

Pour en savoir plus, consultez la section Dépannage.

Diagnostiquer des problèmes de cluster à l'aide de gkectl

Utilisez les commandes gkectl diagnose pour identifier les problèmes de cluster et partager des informations de cluster avec Google. Consultez la page Diagnostiquer les problèmes de cluster.

Exécuter des commandes gkectl de manière détaillée

-v5

Consigner des erreurs gkectl dans stderr

--alsologtostderr

Localiser les journaux gkectl sur le poste de travail administrateur

Même si vous ne transmettez pas ses options de débogage, vous pouvez afficher les journaux gkectl dans le répertoire du poste de travail administrateur suivant :

/home/ubuntu/.config/gke-on-prem/logs

Localiser des journaux de l'API Cluster dans le cluster d'administrateur

Si une VM ne démarre pas après le démarrage du plan de contrôle d'administrateur, vous pouvez essayer de la déboguer en inspectant les journaux des contrôleurs de l'API Cluster dans le cluster d'administrateur :

1. Recherchez le nom du pod des contrôleurs d'API Cluster dans l'espace de noms kube-system, où [ADMIN_CLUSTER_KUBECONFIG] est le chemin d'accès au fichier kubeconfig du cluster d'administrateur :

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] -n kube-system get pods | grep clusterapi-controllers

2. Ouvrez les journaux du pod, où [POD_NAME] correspond au nom du pod. Vous pouvez éventuellement utiliser grep ou un outil similaire pour rechercher les erreurs :

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] -n kube-system logs [POD_NAME] vsphere-controller-manager

Étapes suivantes

• Découvrez comment diagnostiquer les problèmes de cluster.
• Découvrez augur, un outil Open Source permettant de restaurer des objets individuels à partir de sauvegardes etcd.