Cette page a été traduite par l'API Cloud Translation.

Sauvegarder et restaurer un cluster d'utilisateur

Ce document explique comment sauvegarder et restaurer le magasin etcd pour un cluster d'utilisateur. 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.

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é.

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 :

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.

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 /tmp/snapshot.db

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

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

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG cp \
   USER_CLUSTER_NAME/kube-etcd-0:/tmp/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 Anthos clusters on VMware 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.

Recherchez le nom du secret utilisé par etcd dans le cluster d'utilisateur :

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG -n USER_CLUSTER_NAME \
    get secrets | grep kube-etcd-certs

Copiez le fichier manifeste de pod suivant dans un fichier nommé etcd-utility.yaml. Remplacez les éléments suivants :

NODE_NAME : nœud sur lequel le pod kube-etcd-0 est exécuté.
ADMIN_CLUSTER_KUBECONFIG : fichier kubeconfig du cluster d'administrateur.
USER_CLUSTER_NAME : nom du cluster d'utilisateur.
GKE_ON_PREM_VERSION : version du cluster dans lequel vous souhaitez effectuer la restauration etcd (par exemple 1.5.0-gke.0).
KUBE_ETCD_SECRET_NAME : nom du secret utilisé par etcd dans le cluster d'utilisateur, commençant par kube-etcd-certs.

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: gcr.io/gke-on-prem-release/etcd-util:GKE_ON_PREM_VERSION
    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_SECRET_NAME

Déployez le pod utilitaire :

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

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

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

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

Dans votre interface système, supprimez les anciennes données etcd :
```
rm -r var/lib/etcd/*
```
Dans votre interface système, copiez les données etcd restaurées vers leur emplacement permanent :
```
cp -r default.etcd/* var/lib/etcd/
```
Dans votre interface système, saisissez exit pour quitter l'interface système.

Supprimez le pod etcd qui plante :

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

Vérifiez que le pod etcd ne plante plus.

Supprimez le pod utilitaire :

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

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

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

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

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

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

Déployer les pods de l'utilitaire

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

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: gcr.io/gke-on-prem-release/etcd-util:GKE_ON_PREM_VERSION
    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_SECRET_NAME

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

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

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

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

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

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.

Dans votre interface système, supprimez les anciennes données etcd :
```
rm -r var/lib/etcd/*
```
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/
```
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
```
Dans votre interface système, saisissez exit pour quitter l'interface système.

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.

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

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

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

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

Restaurez le PDB du serveur d'API Kubernetes :

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

Sauvegarde automatique des clusters

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 votre clé SSH.
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

Étapes suivantes

Sauvegarder et restaurer un cluster d'administrateur
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.