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

Sauvegarder et restaurer un cluster d'administrateur

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

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_CLUSTER_KUBECONFIG] get nodes -n kube-system -o wide | grep master
```
où [ADMIN_CLUSTER_KUBECONFIG] est le fichier kubeconfig du cluster d'administrateur.
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_CLUSTER_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
```
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]
```
Quittez le conteneur :
```
exit
```

Sauvegarder le magasin etcd d'un cluster d'administrateur

Pour sauvegarder le magasin etcd du cluster d'administrateur :

Obtenez le nom du pod etcd :

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

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

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

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

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

Quittez le conteneur :
```
exit
```
Copiez la sauvegarde hors du conteneur kube-etcd à l'aide de kubectl cp :
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] cp \
kube-system/[ADMIN_ETCD_POD]:tmp/snapshot.db [RELATIVE_DIRECTORY]
```
où [RELATIVE_DIRECTORY] est le chemin d'accès où vous souhaitez stocker votre sauvegarde.

Sauvegarder les secrets d'un cluster d'administrateur

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

Utilisez SSH pour vous connecter au nœud du plan de contrôle d'administrateur :
```
ssh -i vsphere_tmp ubuntu@EXTERNAL_IP
```
Remplacez EXTERNAL_IP par l'adresse IP externe du plan de contrôle d'administrateur que vous avez noté précédemment.
Facultatif, mais vivement recommandé : créez un répertoire de sauvegarde local.

Vous devez modifier les autorisations des secrets de sauvegarde pour les copier hors du nœud :
```
mkdir backup
```
Copiez localement les secrets vers le répertoire de sauvegarde local :
```
sudo cp -r /etc/kubernetes/pki/* backup/
```
Modifiez les autorisations des secrets de sauvegarde :
```
sudo chmod -R a+rX backup/
```
Quittez le nœud du plan de contrôle d'administrateur :
```
exit
```
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
```
Remplacez RELATIVE_DIRECTORY par le 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.

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.
Obtenez une interface système dans le plan de contrôle administrateur :
```
sudo ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Copiez snapshot.db/ vers /mnt :
```
sudo cp snapshot.db /mnt/
```
Créez un répertoire temporaire, tel que backup :

Remarque :Vous n'avez pas besoin de le faire s'il existe déjà un dossier de sauvegarde contenant les secrets.
```
mkdir backup
```
Quittez le plan de contrôle administrateur :
```
exit
```

Copiez les certificats dans backup/ :

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

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.

Arrêtez kube-etcd et kube-apiserver.

sudo mv /etc/kubernetes/manifests/etcd.yaml /tmp/etcd.yaml

sudo mv /etc/kubernetes/manifests/kube-apiserver.yaml /tmp/kube-apiserver.yaml

Copiez les secrets de sauvegarde dans /etc/kubernetes/pki/ :
```
sudo cp -r backup/* /etc/kubernetes/pki/
```

Exécutez etcdctl restore avec Docker :

sudo docker run --rm \
-v '/mnt:/backup' \
-v '/var/lib/etcd:/var/lib/etcd' --env ETCDCTL_API=3 'gcr.io/gke-on-prem-release/etcd-util:GKE_ON_PREM_VERSION' /bin/sh -c "etcdctl snapshot restore '/backup/snapshot.db'; rm -r /var/lib/etcd/*; mv /default.etcd/member/ /var/lib/etcd/"

Redémarrez kube-etcd et kube-apiserver.

sudo mv /tmp/etcd.yaml /etc/kubernetes/manifests/etcd.yaml

sudo mv /tmp/kube-apiserver.yaml /etc/kubernetes/manifests/kube-apiserver.yaml

Vérifiez que kube-etcd et kube-apiserver ont bien commencé.
```
sudo crictl ps -a
```
Remarque :Si l'état kube-etcd ou kube-apiserver est "Quitter", suivez résoudre les problèmes de restauration administrateur.

Copiez /etc/kubernetes/admin.conf dans un dossier .kube pour le rendre accessible depuis le poste de travail administrateur :

mkdir -p [HOME]/.kube

sudo cp -i /etc/kubernetes/admin.conf [HOME]/.kube/config

sudo chown $(id -u):$(id -g) $HOME/.kube/config

Quittez le plan de contrôle administrateur :
```
exit
```
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
```
```
sudo chown $(id -u):$(id -g) 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é.

Résoudre les problèmes de restauration d'un cluster d'administrateur

Si vous rencontrez un problème lors de la restauration du cluster d'administrateur, vous devez contacter l'assistance Google pour le résoudre.

En attendant, vous pouvez vérifier les points suivants pour résoudre le problème.

Recherchez l'ID du conteneur etcd :
```
sudo crictl ps -a | grep [ADMIN_ETCD_POD]
```
où [ADMIN_ETCD_POD] est le nom du pod etcd.
Examinez les journaux du conteneur etc.
```
sudo crictl logs [ETCD_CONTAINER_ID]
```
où [ETCD_CONTAINER_ID] est l'ID du conteneur etcd.
Recherchez les messages de journal de refus d'autorisation suivants tels que

etcdserver: create snapshot directory error:mkdir /var/lib/etcd/member/snap: permission denied
Si des messages d'autorisation refusée sont trouvés, mettez à jour la propriété de /opt/data/var/lib/etcd/
```
sudo chown -R 2001:2001 /opt/data/var/lib/etcd/
```
Vérifiez que kube-etcd et kube-apiserver ont bien commencé.
```
sudo crictl ps
```

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 /tmp/${USER_CLUSTER_NAMESPACE}_snapshot.db"
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} cp ${USER_CLUSTER_NAMESPACE}/kube-etcd-0:tmp/${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 a+rX /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 /tmp/admin_snapshot.db"
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} cp -n kube-system ${admin_etcd}:tmp/admin_snapshot.db $BACKUP_DIR/admin-cluster_snapshot.db

Étapes suivantes

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