Versione 1.6. Questa versione non è più supportata come descritto nelle norme relative al supporto delle versioni di Anthos. Per le patch e gli aggiornamenti più recenti per vulnerabilità di sicurezza, esposizioni e problemi che interessano i cluster Anthos su VMware (GKE on-prem), esegui l'upgrade a una versione supportata. La versione più recente è disponibile qui.

Versioni disponibili

Backup e ripristino di cluster

Questa pagina mostra come eseguire il backup e ripristinare l'archivio etcd di un cluster. Questa pagina fornisce anche uno script che puoi utilizzare per eseguire automaticamente il backup di un negozio etcd di un cluster.

Puoi creare un file di backup per il ripristino in seguito a calamità previste che potrebbero danneggiare i dati di etcd del cluster. Archivia il file di backup in una posizione esterna al cluster e non dipende dall'operazione del cluster.

Limitazioni

Questa procedura non esegue il backup dei dati specifici dell'applicazione.
Questa procedura non esegue il backup dei volumi permanenti.
I carichi di lavoro pianificati dopo aver creato un backup non vengono ripristinati con tale backup.
Impossibile ripristinare un cluster dopo un upgrade non riuscito.
Lo scopo di questa procedura non è ripristinare un cluster eliminato.

Backup di un cluster utente

Un backup del cluster utente è un'istantanea dell'archivio etcd del cluster utente. L'archivio etcd contiene tutti gli oggetti e gli oggetti personalizzati Kubernetes necessari per gestire lo stato del cluster. Lo snapshot contiene i dati necessari per ricreare i componenti e i carichi di lavoro del cluster.

Per creare uno snapshot dell'archivio etcd, procedi nel seguente modo:

Ottieni una shell nel container kube-etcd:
```
kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG exec -it \
   kube-etcd-0 --container kube-etcd --namespace USER_CLUSTER_NAME \
   -- bin/sh
```
dove:
- ADMIN_CLUSTER_KUBECONFIG è il file kubeconfig del cluster di amministrazione.
- USER_CLUSTER_NAME è il nome del cluster utente.

Nella directory principale, crea un backup denominato 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

Nella shell, inserisci exit per uscire dalla shell.

Copia snapshot.db dal contenitore kube-etcd nella directory corrente:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG cp \
   USER_CLUSTER_NAME/kube-etcd-0:snapshot.db \
   --container kube-etcd snapshot.db

Ripristino di un cluster utente da un backup (non alta disponibilità)

Prima di utilizzare un file di backup per ripristinare l'archivio etcd del cluster utente, diagnosi del cluster e risolvi i problemi esistenti. L'utilizzo di un backup per ripristinare un cluster problematico potrebbe ricreare o esacerbare i problemi. Contatta il team di assistenza di Cluster Anthos su VMware per un'ulteriore assistenza con il ripristino dei cluster.

Le istruzioni seguenti spiegano come utilizzare un file di backup per ripristinare un cluster utente nei casi in cui i dati etcd del cluster si siano danneggiati e il pod etcd del cluster utente abbia un arresto anomalo.

Puoi ripristinare i dati etcd eseguendo il deployment di un pod di utilità che sovrascrive i dati danneggiati con il backup. Il server API del cluster di amministrazione deve essere in esecuzione e lo scheduler del cluster di amministrazione deve essere in grado di pianificare nuovi pod.

Copia il seguente manifest del pod in un file denominato etcd-utility.yaml. Sostituisci i segnaposto con altri valori:

NODE_NAME: il nodo in cui è in esecuzione il pod kube-etcd-0.
ADMIN_CLUSTER_KUBECONFIG: il file kubeconfig del cluster di amministrazione.
USER_CLUSTER_NAME: il nome del cluster utente.
GKE_ON_PREM_VERSION: la versione del cluster in cui vuoi eseguire il ripristino etcd (ad esempio 1.5.0-gke.0).

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-certs

Esegui il deployment del pod di utilità:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
   create -f etcd-utility.yaml --namespace USER_CLUSTER_NAME

Copia snapshot.db dalla directory corrente alla directory radice del pod di utilità:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG cp snapshot.db \
   USER_CLUSTER_NAME/etcd-utility-0:snapshot.db --container etcd-utility

Ottieni una shell nel container etcd-utility:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG exec it \
   etcd-utility-0 --container etcd-utility --namespace USER_CLUSTER_NAME \
   -- bin/sh

Nella shell, nella directory principale, esegui il comando seguente per creare una nuova cartella contenente il backup:

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

Nella shell, elimina i vecchi dati etcd:
```
rm -r var/lib/etcd/*
```
Nella shell, copia i dati etcd ripristinati nella posizione permanente:
```
cp -r default.etcd/* var/lib/etcd/
```
Nella shell, inserisci exit per uscire dalla shell.

Elimina il pod etcd con arresto anomalo:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
   delete pod kube-etcd-0 --namespace USER_CLUSTER_NAME

Verifica che il pod etcd non si stia più arrestando in modo anomalo.

Elimina il pod dell'utilità:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
   delete pod etcd-utility-0 --namespace USER_CLUSTER_NAME

Rimuovi etcd-utility.yaml dalla directory corrente:
```
rm etcd-utility.yaml
```

Ripristino di un cluster utente da un backup (HA)

Questa sezione mostra come ripristinare i dati etcd per un cluster utente ad alta disponibilità.

Per un cluster utente ad alta disponibilità, nel cluster di amministrazione sono presenti tre nodi che servono come piani di controllo per il cluster utente. Ciascuno di questi nodi esegue un pod etcd che gestisce i dati etcd su un volume di archiviazione.

Se due dei pod etcd sono integri e i dati sui volumi di archiviazione associati sono invariati, non è necessario utilizzare un file di backup. Questo perché hai ancora un quorum etcd.

Nel raro caso in cui due volumi di archiviazione etcd abbiano dati corrotti, per ripristinarli dovrai utilizzare un file di backup.

Per eseguire i passaggi di questa sezione, devi aver già creato un file snapshot.db come descritto in Eseguire il backup di un cluster utente.

Elenco dei pod e dei nodi etcd

Elenca i pod etcd che gestiscono l'archivio etcd per il cluster utente. Questi pod vengono eseguiti nel cluster di amministrazione:
```
kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG get pods --namespace USER_CLUSTER_NAME \
    --output wide | grep kube-etcd
```
L'output mostra i pod etcd e i nodi in cui vengono eseguiti. I nodi mostrati nell'output sono i nodi nel cluster di amministrazione che fungono da piani di controllo per il cluster utente:
```
NAME              ...   NODE
kube-etcd-0       ...   node-xxx
kube-etcd-1       ...   node-yyy
kube-etcd-2       ...   node-zzz
```
Prendi nota dei nomi dei pod e dei nomi dei nodi del piano di controllo per un secondo momento.

Tieni presente che ogni pod etcd è denominato kube-etcd seguito da un numero. Questo numero è chiamato numero membro del pod. Identifica il pod come membro specifico del cluster etcd che contiene i dati dell'oggetto per il cluster utente. Questa guida utilizza il segnaposto MEMBER_NUMBER per fare riferimento al numero del membro pod etcd.

Nota inoltre che ogni pod nel cluster etcd viene eseguito sul proprio nodo.

Preparazione al deployment dei pod di utilità

Salva un manifest per il PodDisruptionBudget (PDB) per il server API Kubernetes del cluster utente. quindi elimina il 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

Arresta il server API Kubernetes e il deployment di manutenzione etcd. Questo garantisce che nessun componente userà etcd durante il ripristino:

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

Richiama il nome dell'immagine container per i pod etcd.

Deployment dei pod dell'utilità

Esegui i passaggi di questa sezione per ciascun pod etcd.

Richiama il nome del pod etcd e il nome del nodo in cui viene eseguito il pod.

Salva il seguente manifest del pod nella directory corrente in un file denominato 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-certs

Il file manifest precedente descrive un pod di utilità eseguito temporaneamente per ripristinare i dati etcd.

Crea il pod dell'utilità nel cluster di amministrazione:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG apply -f etcd-utility-MEMBER_NUMBER.yaml

Copia il file di backup, snapshot.db, nella directory radice del pod di utilità:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG cp snapshot.db \
   USER_CLUSTER_NAME/etcd-utility-MEMBER_NUMBER:snapshot.db

Ottieni una shell nel container etcd-utility nel pod di utilità:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG exec -it --namespace USER_CLUSTER_NAME \
   etcd-utility-MEMBER_NUMBER --container etcd-utility -- bin/sh

Nella shell, nella directory principale, utilizza snapshot.db per ripristinare i dati 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

Il comando precedente ha archiviato i dati etcd nella directory /kube-etcd-MEMBER_NUMBER.etcd.

Nella shell, elimina i vecchi dati etcd:
```
rm -r var/lib/etcd/*
```
Nella shell, copia i dati etcd ripristinati nella posizione permanente:
```
cp -r kube-etcd-MEMBER_NUMBER.etcd/* var/lib/etcd/
```
Nella shell, rimuovi la directory etcd temporanea e il file di backup:
```
rm -R kube-etcd-MEMBER_NUMBER.etcd/
rm snapshot.db
```
Nella shell, inserisci exit per uscire dalla shell.

Elimina il pod dell'utilità:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG delete pod \
    --namespace USER_CLUSTER_NAME etcd-utility-MEMBER_NUMBER

Riavvio dei componenti

Ora che hai eseguito il deployment ed eliminato i pod di utilità, devi riavviare alcuni componenti del cluster.

Riavvia i pod in kube-etcd StatefulSet:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG rollout restart statefulset \
    --namespace USER_CLUSTER_NAME kube-etcd

Avvia i server API Kubernetes per il cluster utente:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG scale statefulset --replicas 3 \
   --namespace USER_CLUSTER_NAME kube-apiserver

Avvia il deployment di manutenzione etcd per il cluster utente:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG scale deployment --replicas 1 \
    --namespace=USER_CLUSTER_NAME  gke-master-etcd-maintenance

Ripristina il PDB per il server API Kubernetes:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG apply -f kube-apiserver-pdb.yaml

Backup di un cluster di amministrazione

Un backup del cluster di amministrazione contiene quanto segue:

Un'istantanea del cluster di amministrazione e così via.
I secret del piano di controllo dell'amministratore, necessari per l'autenticazione nei cluster di amministrazione e degli utenti.

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

Individua l'indirizzo IP esterno del cluster di amministrazione, utilizzato per accedere tramite SSH al piano di controllo 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 dei comandi, 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 utilizzare il shell nel piano di controllo amministrativo utilizzando questa chiave privata:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Esci dal contenitore:
```
exit
```

Backup dello store etcd di un cluster di amministrazione

Per eseguire il backup dello store etcd del cluster di amministrazione:

Ottieni 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"}'

Accedi al 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 snapshot.db

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

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 piano di controllo dell'amministratore:
```
ssh -i vsphere_tmp ubuntu@EXTERNAL_IP
```
Sostituisci EXTERNAL_IP con l'indirizzo IP esterno del piano di controllo dell'amministratore, come annotato in precedenza.
Facoltativo ma vivamente consigliato: crea una directory di backup locale.

Devi cambiare le autorizzazioni di backup del secret per copiarle dal nodo.
```
mkdir backup
```
Copia localmente i Secret nella directory di backup locale:
```
sudo cp -r /etc/kubernetes/pki/* backup/
```
Modifica le autorizzazioni dei Secret di backup:
```
sudo chmod -R +rw backup/
```
Esci dal nodo del piano di controllo dell'amministratore:
```
exit
```
Esegui scp per copiare la cartella di backup dal nodo del piano di controllo dell'amministratore:
```
sudo scp -r -i vsphere_tmp  ubuntu@EXTERNAL_IP:backup/ RELATIVE_DIRECTORY
```
Sostituisci RELATIVE_DIRECTORY con un 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 piani di controllo utente che ha gestito al momento della creazione dello snapshot 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 dell'amministratore, che hai raccolto in precedenza.
Accedi al piano di controllo dell'amministratore:
```
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 Secret.
```
mkdir backup
```
Esci dal piano di controllo dell'amministratore:
```
exit
```

Copia i certificati in backup/:

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

Shell nel nodo del piano di controllo dell'amministratore:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
dove [EXTERNAL_IP] è l'indirizzo IP esterno del piano di controllo dell'amministratore, 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

Copia /etc/kubernetes/admin.conf in una cartella .kube per 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

Esci dal piano di controllo dell'amministratore:
```
exit
```
Copia il file kubeconfig appena generato dal nodo amministratore:
```
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 piano di controllo dell'amministratore.
- [HOME] è la home directory sul nodo amministratore.
Ora puoi utilizzare questo nuovo file kubeconfig per accedere al cluster ripristinato.

Backup automatico del cluster

Puoi utilizzare lo script fornito qui come esempio su come eseguire automaticamente il backup dei tuoi cluster. Tieni presente che il seguente script non è supportato e deve essere utilizzato solo come riferimento per scrivere uno script migliore, più efficace 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 dell'amministratore e del cluster utente. Questo percorso non deve esistere.
Imposta il percorso del file kubeconfig del cluster di amministrazione ADMIN_CLUSTER_KUBECONFIG
Imposta il nome del cluster utente come USER_CLUSTER_NAMESPACE. Il nome del cluster utente è uno spazio dei nomi nel cluster di amministrazione.
Imposta EXTERNAL_IP sul VIP prenotato per il servizio del piano di controllo dell'amministratore.
Imposta SSH_PRIVATE_KEY sul percorso della chiave SSH creata quando configuri la workstation di amministrazione.
Se utilizzi una rete privata, imposta JUMP_IP sull'indirizzo IP del jump server della 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 ${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

Passaggi successivi

Scopri come diagnosticare i problemi del cluster
Scopri augur, uno strumento open source per ripristinare singoli oggetti dai backup etcd.