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.
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 snapshot.db
Dans votre interface système, saisissez
exit
pour quitter l'interface système.Copiez
snapshot.db
du conteneurkube-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 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 podkube-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 parkube-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 utilitaires
Suivez la procédure décrite dans cette section pour chacun de vos pods etcd.
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
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éesnapshot.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
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]: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 +rw 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 copiersnapshot.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
: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
etkube-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
etkube-apiserver
.sudo mv /tmp/etcd.yaml /etc/kubernetes/manifests/etcd.yaml
sudo mv /tmp/kube-apiserver.yaml /etc/kubernetes/manifests/kube-apiserver.yaml
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é.
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
- 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.