Backup e ripristino di cluster

Questa pagina descrive come eseguire il backup e il ripristino dei cluster creati con la modalità privata Anthos. Queste istruzioni si applicano a tutti i tipi di cluster supportati dalla modalità privata Anthos.

Avviso: l'utilizzo di un file di backup per ripristinare i dati ecc. è un'ultima risorsa. Consigliamo di non eseguire il ripristino da un file di backup se il cluster non è completamente danneggiato. Contatta l'Assistenza Google se hai bisogno di aiuto per decidere la linea d'azione migliore.

Backup di un cluster

Il processo di backup è composto da due parti. Innanzitutto, viene creato uno snapshot dal negozio etcd. I certificati PKI correlati vengono quindi salvati in un file tar. L'archivio etcd è il backend di Kubernetes per tutti i dati dei cluster e contiene tutti gli oggetti Kubernetes e gli oggetti personalizzati necessari per gestire lo stato dei cluster. I certificati PKI vengono utilizzati per l'autenticazione tramite TLS. Il backup di questi dati viene eseguito dal piano di controllo del cluster o da uno dei piani di controllo per un'alta disponibilità (HA)

Ti consigliamo di effettuare periodicamente il backup dei cluster per garantire che i dati degli snapshot siano relativamente aggiornati. La frequenza dei backup dipende dalla frequenza con cui si verificano cambiamenti significativi per i cluster.

Crea un'istantanea del negozio etcd

In modalità privata di Anthos, un pod denominato etcd-CONTROL_PLANE_NAME nello spazio dei nomi del sistema kube esegue il etcd per quel piano di controllo. Per eseguire il backup dello spazio di archiviazione del cluster, esegui la procedura seguente dalla workstation dell'amministratore:

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 e così via.

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/healthcheck-client.crt \
       --key=/etc/kubernetes/pki/etcd/healthcheck-client.key \
       snapshot save snapshotDATESTAMP.db
   

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

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

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

6. Archivia il file degli snapshot in una posizione esterna al cluster e non dipende dall'operazione del cluster.

Archiviare i certificati PKI

I certificati da sottoporre a backup si trovano nella directory /etc/kubernetes/pki del piano di controllo. I certificati PIK insieme al file snapshot.db dell'archivio etcd sono necessari per recuperare un cluster in caso di arresto completo del piano di controllo. I passaggi seguenti mostrano 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 di un file tar all'interno del piano di controllo conserva tutte le autorizzazioni del file del certificato.

3. Esci dal piano di controllo e, dalla workstation, copia il file tar contenente i certificati in una posizione preferita sulla workstation.

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

Ripristino di un cluster

Il ripristino di un cluster da un backup è un ultimo ricorso e deve essere utilizzato quando un cluster ha avuto esito catastrofico e non può essere restituito ad altri servizi. Ad esempio, i dati etcd sono danneggiati oppure il pod etcd è in un loop di arresto anomalo.

Il processo di ripristino del cluster è composto da due parti. Innanzitutto, i certificati PKI vengono ripristinati sul piano di controllo. A questo punto, vengono ripristinati i dati dell'archivio etcd.

Ripristina certificati PKI

Supponendo che tu abbia eseguito il backup dei certificati PKI come descritto in Archiviazione dei certificati PKI, i passaggi seguenti descrivono come 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 dall'esecuzione o meno del cluster in modalità alta disponibilità (HA) e, in caso affermativo, dalla conservazione del quorum. Utilizza la seguente guida per ripristinare l'archivio etcd per una determinata situazione di errore del cluster:

• Se il cluster con errori non è in esecuzione in modalità alta disponibilità, ripristina l'archivio etcd sul piano di controllo seguendo i passaggi riportati di seguito.

• Se il cluster è in esecuzione in modalità alta disponibilità e il quorum viene conservato, non fare nulla. Se il quorum viene conservato, non è necessario ripristinare i cluster con errori.

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

Per rimuovere e ripristinare l'archivio etcd su un piano di controllo per un cluster con errori:

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

   ssh root@CONTROL_PLANE_NAME "mkdir /backup"
   

   Questo passaggio non è strettamente obbligatorio, ma ti consigliamo di farlo. Per i passaggi seguenti si presuppone che tu abbia creato una directory /backup.

2. Copia il file di snapshot e così via, snapshot.db dalla workstation alla directory backup sul piano di controllo del cluster.

   sudo scp snapshot.db root@CONTROL_PLANE_NAME:/backup
   

3. Interrompi i pod statici etcd e kube-apiserver spostando i relativi file manifest dalla directory /etc/kubernetes/manifests nella 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 docker.

   sudo docker run --rm -t \
       -v /var/lib:/var/lib \
       -v /etc/kubernetes/pki/etcd:/etc/kubernetes/pki/etcd \
       -v /backup:/backup \
       --env ETCDCTL_API=3 \
       k8s.gcr.io/etcd:3.2.24 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 sono disponibili nel file manifest etcd.yaml che è stato spostato nella directory /backup.

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

7. Sposta i manifest manifest etcd e kube-apiserver nella directory /manifests in modo che i pod statici possano riavviarsi.

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

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

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

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

   Ad esempio:

   ETCDCTL_API=3 etcdctl --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt  \
       --key=/etc/kubernetes/pki/etcd/healthcheck-client.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
   

   Se l'operazione ha esito positivo per ogni endpoint, il cluster dovrebbe funzionare correttamente.