Anthos clusters on VMware ora è Google Distributed Cloud (solo software) per VMware. Per ulteriori informazioni, consulta la panoramica del prodotto.

Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il backup e il ripristino di un cluster di amministrazione

Questo documento illustra come eseguire il backup e il ripristino dello spazio dati etcd per un cluster amministrativo creato con Google Distributed Cloud (solo software) per VMware. Questo documento fornisce anche uno script che puoi utilizzare per eseguire automaticamente il backup dello spazio dati etcd di un cluster. Puoi anche eseguire il backup e il ripristino di un cluster di amministrazione utilizzando lo strumento a riga di comando gkectl.

Puoi creare un file di backup per il recupero da eventi catastrofici imprevisti che potrebbero danneggiare i dati etcd del tuo cluster. Archivia il file di backup in una posizione al di fuori del cluster e indipendente dal suo funzionamento.

Limitazioni

La procedura di backup e ripristino descritta in questo documento presenta i seguenti limiti:

Questa procedura non esegue il backup dei dati specifici dell'applicazione.
Questa procedura non esegue il backup dei PersistentVolume.
I workload pianificati dopo la creazione di un backup non vengono ripristinati con quel backup.
Non puoi ripristinare un cluster dopo un upgrade non riuscito.
Questa procedura non è pensata per ripristinare un cluster eliminato.

Per ulteriori informazioni sulle limitazioni, consulta Incompatibilità dell'infrastruttura.

Eseguire il backup di un cluster di amministrazione

Un backup del cluster di amministrazione contiene quanto segue:

Uno snapshot di etcd del cluster di amministrazione.
I secret del piano di controllo amministrativo, necessari per l'autenticazione ai cluster di amministrazione e utente.

Completa i seguenti passaggi prima di creare un backup del cluster di amministrazione:

Trova l'indirizzo IP esterno del cluster di amministrazione, utilizzato per accedere tramite SSH al control plane del cluster di amministrazione:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get nodes -n kube-system -o wide | grep master
```
dove [ADMIN_CLUSTER_KUBECONFIG] è il file kubeconfig del cluster di amministrazione.
Crea una chiave SSH denominata vsphere_tmp dalla chiave privata del cluster di amministrazione.

Puoi trovare la chiave privata nei secret dei cluster di amministrazione:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get secrets sshkeys -n kube-system -o yaml
```
Nell'output del comando, puoi trovare la chiave privata nel campo vsphere_tmp.

Copia la chiave privata in vsphere_tmp:
```
echo "[PRIVATE_KEY]" | base64 -d > vsphere_tmp; chmod 600 vsphere_tmp
```
Verifica di poter accedere al piano di controllo amministrativo utilizzando questa chiave privata:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Esci dal contenitore:
```
exit
```

Eseguire il backup dello spazio dati etcd di un cluster di amministrazione

Per eseguire il backup dello spazio dati etcd del cluster di amministrazione:

Recupera il nome del pod etcd:

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

Esegui shell nel container kube-etcd del pod:

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

dove [ADMIN_ETCD_POD] è il nome del pod etcd.

Dalla shell, utilizza etcdctl per creare un backup denominato snapshot.db nella directory locale:

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

Esci dal contenitore:
```
exit
```
Copia il backup dal contenitore kube-etcd utilizzando kubectl cp:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] cp \
kube-system/[ADMIN_ETCD_POD]:tmp/snapshot.db [RELATIVE_DIRECTORY]
```
dove [RELATIVE_DIRECTORY] è il percorso in cui vuoi archiviare il backup.

Eseguire il backup dei secret di un cluster di amministrazione

Per eseguire il backup dei secret del piano di controllo dell'amministratore:

Utilizza SSH per connetterti al nodo del control plane amministrativo:
```
ssh -i vsphere_tmp ubuntu@EXTERNAL_IP
```
Sostituisci EXTERNAL_IP con l'indirizzo IP esterno del control plane amministrativo, che hai annotato in precedenza.
(Facoltativo, ma vivamente consigliato) Crea una directory di backup locale.

Devi modificare le autorizzazioni dei secret di backup per copiarli dal node.
```
mkdir backup
```
Copia i secret localmente nella directory di backup locale:
```
sudo cp -r /etc/kubernetes/pki/* backup/
```
Modifica le autorizzazioni dei secret di backup:
```
sudo chmod -R a+rX backup/
```
Esci dal nodo del control plane di amministrazione:
```
exit
```
Esegui scp per copiare la cartella di backup dal nodo del piano di controllo amministrativo:
```
sudo scp -r -i vsphere_tmp  ubuntu@EXTERNAL_IP:backup/ RELATIVE_DIRECTORY
```
Sostituisci RELATIVE_DIRECTORY con il percorso in cui vuoi archiviare il backup.

Ripristino di un cluster di amministrazione

La procedura seguente ricrea un cluster di amministrazione di cui è stato eseguito il backup e tutti i control plane utente gestiti al momento della creazione dello snapshot di etcd.

Esegui scp per copiare snapshot.db nel piano di controllo dell'amministratore:
```
sudo scp -i vsphere_tmp snapshot.db ubuntu@[EXTERNAL_IP]:
```
dove [EXTERNAL_IP] è l'indirizzo IP esterno del piano di controllo amministrativo che hai raccolto in precedenza.
Esegui il logon al control plane di amministrazione:
```
sudo ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Copia snapshot.db/ in /mnt:
```
sudo cp snapshot.db /mnt/
```
Crea una directory temporanea, ad esempio backup:

Nota: non è necessario eseguire questa operazione se esiste già una cartella di backup contenente i segreti.
```
mkdir backup
```
Uscire dal control plane di amministrazione:
```
exit
```

Copia i certificati in backup/:

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

Esegui lo shell nel nodo del control plane di amministrazione:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
dove [EXTERNAL_IP] è l'indirizzo IP esterno del piano di controllo amministrativo che hai raccolto in precedenza.

Interrompi kube-etcd e kube-apiserver.

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

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

Copia i secret di backup in /etc/kubernetes/pki/:
```
sudo cp -r backup/* /etc/kubernetes/pki/
```

Esegui etcdctl restore con 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/"

Riavvia kube-etcd e kube-apiserver.

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

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

Verifica che kube-etcd e kube-apiserver siano stati avviati.
```
sudo crictl ps -a
```
Nota: se kube-etcd o kube-apiserver sono in uno stato di uscita, segui la procedura per la risoluzione dei problemi relativi al ripristino dell'amministratore.

Copia /etc/kubernetes/admin.conf in una cartella .kube in modo che sia possibile accedervi dalla workstation di amministrazione:

mkdir -p [HOME]/.kube

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

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

Uscire dal control plane di amministrazione:
```
exit
```
Copia il file kubeconfig appena generato dal nodo di amministrazione:
```
sudo scp -i vsphere_tmp ubuntu@[EXTERNAL_IP]:[HOME]/.kube/config kubeconfig
```
```
sudo chown $(id -u):$(id -g) kubeconfig
```
dove:
- [EXTERNAL_IP] è l'indirizzo IP esterno del control plane di amministrazione.
- [HOME] è la home directory sul nodo di amministrazione.
Ora puoi utilizzare questo nuovo file kubeconfig per accedere al cluster ripristinato.

Risoluzione dei problemi relativi al ripristino di un cluster di amministrazione

Se riscontri un problema durante il ripristino del cluster amministrativo, devi contattare l'Assistenza Google per risolvere il problema.

Nel frattempo, puoi controllare quanto segue per risolvere ulteriormente il problema.

Trovare l'ID contenitore etcd
```
sudo crictl ps -a | grep [ADMIN_ETCD_POD]
```
dove [ADMIN_ETCD_POD] è il nome del pod etcd.
Esamina i log del contenitore etc
```
sudo crictl logs [ETCD_CONTAINER_ID]
```
dove [ETCD_CONTAINER_ID] è l'ID del contenitore etcd.
Cerca i seguenti messaggi di log di autorizzazione rifiutata, ad esempio

etcdserver: create snapshot directory error:mkdir /var/lib/etcd/member/snap: permission denied
Se vengono trovati messaggi di autorizzazione negata, aggiorna la proprietà di /opt/data/var/lib/etcd/
```
sudo chown -R 2001:2001 /opt/data/var/lib/etcd/
```
Verifica che kube-etcd e kube-apiserver siano stati avviati.
```
sudo crictl ps
```

Backup automatico del cluster

Puoi utilizzare lo script fornito qui come esempio di come eseguire automaticamente il backup dei cluster. Tieni presente che lo script seguente non è supportato e deve essere utilizzato solo come riferimento per scrivere uno script migliore, più solido e completo. Prima di eseguire lo script, inserisci i valori per le cinque variabili all'inizio dello script:

Imposta BACKUP_DIR sul percorso in cui vuoi archiviare i backup del cluster di amministrazione e utente. Questo percorso non dovrebbe esistere.
Imposta ADMIN_CLUSTER_KUBECONFIG sul percorso del file kubeconfig del cluster di amministrazione
Imposta USER_CLUSTER_NAMESPACE sul nome del cluster utente. Il nome del tuo cluster utente è uno spazio dei nomi nel cluster di amministrazione.
Imposta EXTERNAL_IP sul VIP che hai riservato per il servizio del piano di controllo amministrativo.
Imposta SSH_PRIVATE_KEY sul percorso della chiave SSH.
Se utilizzi una rete privata, imposta JUMP_IP sull'indirizzo IP del jump server della tua rete.

#!/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

Passaggi successivi

Eseguire il backup e il ripristino di un cluster utente
Diagnostica dei problemi relativi ai cluster
Scopri di più su augur, uno strumento open source per il ripristino di singoli oggetti dai backup di etcd.