Backup e ripristino di cluster

Questa pagina è dedicata agli operatori dell'infrastruttura.

Questa pagina descrive come eseguire il backup e il ripristino dei cluster creati con Anthos in esecuzione in modalità disconnessa. Queste istruzioni si applicano a tutti i tipi di cluster supportati da Anthos.

Avviso: l'utilizzo di un file di backup per ripristinare i dati etcd è l'ultima risorsa. Sconsigliamo il ripristino da un file di backup, a meno che il cluster non sia completamente danneggiato. Contatta l'Assistenza Google per decidere qual è il miglior provvedimento da prendere in considerazione.

Effettua il backup di un cluster

La procedura di backup è composta da due parti. Innanzitutto, viene creato uno snapshot dallo store etcd. Successivamente, i certificati PKI correlati vengono salvati in un file tar. L'archivio etcd è l'archivio di supporto di Kubernetes per tutti i dati del cluster e contiene tutti gli oggetti Kubernetes e gli oggetti personalizzati necessari per gestire lo stato del cluster. I certificati PKI vengono utilizzati per l'autenticazione tramite TLS. Questi dati vengono sottoposti a backup dal piano di controllo del cluster o da uno dei piani di controllo per una alta disponibilità

Ti consigliamo di eseguire regolarmente il backup dei tuoi cluster per assicurarti che i dati degli snapshot siano relativi al momento attuale. La frequenza dei backup dipende dalla frequenza con cui si verificano cambiamenti significativi per i tuoi cluster.

Crea un'istantanea del negozio etcd

In Anthos, un pod denominato etcd-CONTROL_PLANE_NAME nello spazio dei nomi kube-system esegue l'etcd per quel piano di controllo. Per eseguire il backup dell'archivio etcd del cluster, esegui i passaggi seguenti della workstation di amministrazione:

1. Utilizza kubectl get po per identificare il pod etcd.

   kubectl --kubeconfig CLUSTER_KUBECONFIG get po -n kube-system \
       -l 'component=etcd,tier=control-plane'
   

   La risposta include il nome del pod etcd e il relativo stato.

2. Utilizza kubectl describe pod per visualizzare i container in esecuzione nel pod etcd, incluso il container etcd.

   kubectl --kubeconfig CLUSTER_KUBECONFIG describe pod ETCD_POD_NAME -n kube-system
   

3. Esegui una shell Bash nel container etcd.

   kubectl --kubeconfig CLUSTER_KUBECONFIG exec -it \
       ETCD_POD_NAME --container etcd --namespace kube-system \
       -- bin/sh
   

4. Dalla shell all'interno del container etcd, utilizza etcdctl (versione 3 dell'API) per salvare uno snapshot, snapshot.db, dell'archivio etcd.

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

   Sostituisci DATESTAMP con la data corrente per evitare sovrascritture di snapshot successivi.

5. Esci dalla shell del container ed esegui il comando seguente per copiare il file snapshot nella workstation di amministrazione.

   kubectl --kubeconfig CLUSTER_KUBECONFIG cp \
       kube-system/ETCD_POD_NAME:/tmp/snapshot.db \
       --container etcd snapshot.db
   

6. Copia il programma binario etcdctl dal pod etcd in modo che possa essere utilizzato durante il processo di ripristino.

   kubectl --kubeconfig CLUSTER_KUBECONFIG cp \
     kube-system/ETCD_POD_NAME:/usr/local/bin/etcdctl \
     --container etcd etcdctl
   

7. Archivia il file di snapshot e il programma binario etcdctl in una posizione esterna al cluster e non dipende dall'operazione del cluster.

Archivia i certificati PKI

I certificati di cui eseguire il backup si trovano nella directory /etc/kubernetes/pki del piano di controllo. I certificati PIK insieme al file etcd store snapshot.db sono necessari per recuperare un cluster nel caso in cui il piano di controllo smetta completamente di funzionare. I passaggi seguenti consentono di creare un file tar contenente i certificati PKI.

1. Utilizza ssh per connetterti al piano di controllo del cluster come root.

   ssh root@CONTROL_PLANE_NAME
   

2. Dal piano di controllo, crea un file tar, certs_backup.tar.gz, con i contenuti della directory /etc/kubernetes/pki.

   tar -czvf certs_backup.tar.gz -C /etc/kubernetes/pki .
   

   La creazione del file tar all'interno del piano di controllo conserva tutte le autorizzazioni del file del certificato.

3. Esci dal piano di controllo e copia dal file tar contenente i certificati nella posizione preferita della workstation.

   sudo scp root@CONTROL_PLANE_NAME:certs_backup.tar.gz BACKUP_PATH
   

Ripristinare un cluster

Il ripristino di un cluster da un backup è l'ultima risorsa e deve essere utilizzato quando un cluster ha subito un errore catastrofico e non può essere restituito in altro modo. Ad esempio, i dati etcd sono danneggiati o il pod etcd si trova in un loop di arresto anomalo.

Il processo di ripristino del cluster si compone di due parti. Innanzitutto, i certificati PKI vengono ripristinati nel piano di controllo. Successivamente, vengono ripristinati i dati del negozio etcd.

Ripristina certificati PKI

Supponendo che tu abbia eseguito il backup dei certificati PKI come descritto in Archiviare i certificati PKI, procedi nel seguente modo per ripristinare i certificati dal file tar a un piano di controllo.

1. Copia il file tar dei certificati PKI (certs_backup.tar.gz) dalla workstation al piano di controllo del cluster.

   sudo scp -r BACKUP_PATH/certs_backup.tar.gz root@CONTROL_PLANE_NAME:~/
   

2. Utilizza ssh per connetterti al piano di controllo del cluster come root.

   ssh root@CONTROL_PLANE_NAME
   

3. Dal piano di controllo, estrai i contenuti del file tar nella directory /etc/kubernetes/pki.

   tar -xzvf certs_backup.tar.gz -C /etc/kubernetes/pki/
   

4. Esci dal piano di controllo.

Ripristina il negozio etcd

Quando si ripristina l'archivio etcd, il processo dipende dalla presenza o meno del cluster in modalità alta disponibilità (HA) e, in caso affermativo, dalla presenza o meno del quorum. Utilizza le seguenti istruzioni per ripristinare l'archivio etcd in una situazione di errore del cluster specifico:

• Se il cluster in errore non viene eseguito in modalità ad alta disponibilità, ripristina l'archivio etcd sul piano di controllo seguendo i passaggi riportati di seguito.

• Se il cluster è in esecuzione in modalità ad alta disponibilità e il quorum viene conservato, non eseguire alcuna operazione. Se un quorum viene conservato, non è necessario ripristinare i cluster non riusciti.

• Se il cluster è in esecuzione in modalità ad alta disponibilità e il quorum viene perso, ripeti i passaggi seguenti per ripristinare l'archivio etcd per ciascun membro non riuscito.

Segui questi passaggi dalla workstation per rimuovere e ripristinare l'archivio etcd su un piano di controllo in caso di cluster non riuscito:

1. Crea una directory /backup nella directory radice del piano di controllo.

   ssh root@CONTROL_PLANE_NAME "mkdir /backup"
   

   Questo passaggio non è strettamente obbligatorio, ma è consigliabile. I passaggi successivi spiegano come hai creato una directory /backup.

2. Copia il file snapshot etcd, il programma binario snapshot.db e etcdctl dalla workstation nella directory backup sul piano di controllo del cluster.

   sudo scp snapshot.db root@CONTROL_PLANE_NAME:/backup
   sudo scp etcdctl root@CONTROL_PLANE_NAME:/backup
   

3. Interrompi i pod statici etcd e kube-apiserver spostando i file manifest dalla directory /etc/kubernetes/manifests alla directory /backup.

   sudo mv /etc/kubernetes/manifests/etcd.yaml /backup/etcd.yaml
   sudo mv /etc/kubernetes/manifests/kube-apiserver.yaml /backup/kube-apiserver.yaml
   

4. Rimuovi la directory dei dati etcd.

   rm -rf /var/lib/etcd/
   

5. Esegui il ripristino degli snapshot etcdctl utilizzando il programma binario salvato.

   sudo chmod +x /backup/etcdctl
   sudo ETCDCTL_API=3 /backup/etcdctl \
       --cacert=/etc/kubernetes/pki/etcd/ca.crt \
       --cert=/etc/kubernetes/pki/etcd/server.crt \
       --key=/etc/kubernetes/pki/etcd/server.key \
       --data-dir=/var/lib/etcd \
       --name=CONTROL_PLANE_NAME \
       --initial-advertise-peer-urls=https://CONTROL_PLANE_IP:2380 \
       --initial-cluster=CONTROL_PLANE_NAME=https://CONTROL_PLANE_IP:2380 \
       snapshot restore /backup/snapshot.db
   

   Le voci per --name, --initial-advertise-peer-urls e --initial-cluster si trovano nel file manifest etcd.yaml che è stato spostato nella directory /backup.

6. Assicurati che /var/lib/etcd sia stato ricreato e che sia stato creato un nuovo membro in /var/lib/etcd/member.

7. Cambia il proprietario della directory /var/lib/etcd/member in 2003. A partire dalla versione 1.10.0 di Anthos, il container etcd viene eseguito come utente non root con UID e GID di 2003.

   sudo chown -R 2003:2003 /var/lib/etcd
   

8. Sposta i manifest etcd e kube-apiserver nella directory /manifests in modo che i pod statici possano essere riavviati.

   sudo mv /backup/etcd.yaml /etc/kubernetes/manifests/etcd.yaml
   sudo mv /backup/kube-apiserver.yaml /etc/kubernetes/manifests/kube-apiserver.yaml
   

9. Utilizza etcdctl per verificare che il membro aggiunto funzioni correttamente.

   ETCDCTL_API=3 etcdctl --cert=/etc/kubernetes/pki/etcd/peer.crt  \
       --key=/etc/kubernetes/pki/etcd/peer.key \
       --cacert=/etc/kubernetes/pki/etcd/ca.crt \
       --endpoints=CONTROL_PLANE_IP:2379 \
       endpoint health
   

   Se stai ripristinando più membri non riusciti, una volta ripristinati tutti i membri non riusciti, esegui il comando con gli indirizzi IP del piano di controllo di tutti i membri ripristinati nel campo --endpoints'.

   Ad esempio:

   ETCDCTL_API=3 etcdctl --cert=/etc/kubernetes/pki/etcd/peer.crt  \
       --key=/etc/kubernetes/pki/etcd/peer.key \
       --cacert=/etc/kubernetes/pki/etcd/ca.crt \
       --endpoints=10.200.0.3:2379,10.200.0.4:2379,10.200.0.5:2379 \
       endpoint health
   

   Il completamento corretto di ogni endpoint dovrebbe funzionare correttamente.

Passaggi successivi

• Scopri come eliminare i cluster.