Administratorcluster sichern und wiederherstellen

In diesem Dokument wird gezeigt, wie Sie den etcd-Speicher für einen Administratorcluster sichern und wiederherstellen, der mit Google Distributed Cloud (nur Software) für VMware erstellt wurde. Dieses Dokument enthält auch ein Skript, mit dem Sie den etcd-Speicher eines Clusters automatisch sichern können. Sie können Administratorcluster auch mit dem gkectl-Befehlszeilentool sichern und wiederherstellen.

Sie können eine Sicherungsdatei zur Wiederherstellung bei unerwarteten Notfällen erstellen, die die etcd-Daten Ihres Clusters beschädigen könnten. Speichern Sie die Sicherungsdatei an einem Speicherort, der sich außerhalb des Clusters befindet und nicht von der Funktionsfähigkeit des Clusters abhängt.

Beschränkungen

Das in diesem Dokument beschriebene Verfahren zum Sichern und Wiederherstellen hat folgende Einschränkungen:

Mit diesem Verfahren werden keine anwendungsspezifischen Daten gesichert.
Mit diesem Verfahren werden keine PersistentVolumes gesichert.
Nach dem Erstellen einer Sicherung geplante Arbeitslasten werden mit dieser Sicherung nicht wiederhergestellt.
Sie können einen Cluster nach einem fehlgeschlagenen Upgrade nicht mehr wiederherstellen.
Dieses Verfahren ist nicht zum Wiederherstellen gelöschter Cluster gedacht

Weitere Informationen zu Einschränkungen finden Sie unter Inkompatibilität der Infrastruktur.

Administratorcluster sichern

Eine Administratorcluster-Sicherung enthält Folgendes:

Einen Snapshot des etcd-Speichers des Administratorclusters
Die Secrets der Administrator-Steuerungsebene, die für die Authentifizierung bei den Administrator- und Nutzerclustern erforderlich sind.

Führen Sie die folgenden Schritte aus, bevor Sie eine Administratorcluster-Sicherung erstellen:

Ermitteln Sie die externe IP-Adresse des Administratorclusters, die für die SSH-Verbindung zur Steuerungsebene des Administratorclusters verwendet wird:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get nodes -n kube-system -o wide | grep master
```
Dabei ist [ADMIN_CLUSTER_KUBECONFIG] die kubeconfig-Datei des Administratorclusters.
Erstellen Sie aus dem privaten Schlüssel des Administratorclusters einen SSH-Schlüssel namens vsphere_tmp.

Sie finden den privaten Schlüssel in den Administratorcluster-Secrets:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get secrets sshkeys -n kube-system -o yaml
```
In der Befehlsausgabe finden Sie den privaten Schlüssel im Feld vsphere_tmp.

Kopieren Sie den privaten Schlüssel in vsphere_tmp:
```
echo "[PRIVATE_KEY]" | base64 -d > vsphere_tmp; chmod 600 vsphere_tmp
```
Prüfen Sie, ob Sie mit diesem privaten Schlüssel eine Shell-Verbindung zur Administrator-Steuerungsebene herstellen können:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Schließen Sie den Container:
```
exit
```

etcd-Speicher eines Administratorclusters sichern

So sichern Sie den etcd-Speicher des Administratorclusters:

Rufen Sie den Namen des etcd-Pods ab:

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

Stellen Sie eine Shell-Verbindung zum kube-etcd-Container des Pods her:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG]  exec -it \
    -n kube-system [ADMIN_ETCD_POD] -- bin/sh
```
Dabei ist [ADMIN_ETCD_POD] der Name des etcd-Pods.

Erstellen Sie über die Shell mit etcdctl eine Sicherung mit dem Namen snapshot.db im lokalen Verzeichnis:

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

Schließen Sie den Container:
```
exit
```
Kopieren Sie die Sicherung mit kubectl cp aus dem kube-etcd-Container:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] cp \
kube-system/[ADMIN_ETCD_POD]:tmp/snapshot.db [RELATIVE_DIRECTORY]
```
Dabei ist [RELATIVE_DIRECTORY] ein Pfad, unter dem Sie Ihre Sicherung speichern möchten.

Secrets eines Administratorclusters sichern

So sichern Sie die Secrets der Administrator-Steuerungsebene:

Verwenden Sie SSH, um eine Verbindung zum Knoten der Administrator-Steuerungsebene herzustellen:
```
ssh -i vsphere_tmp ubuntu@EXTERNAL_IP
```
Ersetzen Sie EXTERNAL_IP durch die externe IP-Adresse der Administrator-Steuerungsebene, die Sie zuvor notiert haben.
Optional, aber sehr empfehlenswert: Erstellen Sie ein lokales Sicherungsverzeichnis.

Sie müssen die Berechtigungen der Sicherungs-Secrets ändern, um sie aus dem Knoten kopieren zu können:
```
mkdir backup
```
Kopieren Sie die Secrets lokal in das lokale Sicherungsverzeichnis:
```
sudo cp -r /etc/kubernetes/pki/* backup/
```
Ändern Sie die Berechtigungen der Sicherungs-Secrets:
```
sudo chmod -R a+rX backup/
```
Beenden Sie den Knoten der Administrator-Steuerungsebene:
```
exit
```
Führen Sie scp aus, um den Sicherungsordner aus dem Knoten der Administrator-Steuerungsebene zu kopieren:
```
sudo scp -r -i vsphere_tmp  ubuntu@EXTERNAL_IP:backup/ RELATIVE_DIRECTORY
```
Ersetzen Sie RELATIVE_DIRECTORY durch einen Pfad, unter dem Sie Ihre Sicherung speichern möchten.

Administratorcluster wiederherstellen

Im Folgenden werden ein gesicherter Administratorcluster und alle Nutzersteuerungsebenen, die er beim Erstellen des etcd-Snapshots verwaltet hat, neu erstellt.

Führen Sie scp aus, um snapshot.db in die Administrator-Steuerungsebene zu kopieren:
```
sudo scp -i vsphere_tmp snapshot.db ubuntu@[EXTERNAL_IP]:
```
Dabei ist [EXTERNAL_IP] die externe IP-Adresse der Administrator-Steuerungsebene, die Sie zuvor ermittelt haben.
Stellen Sie eine Shell-Verbindung zur Administrator-Steuerungsebene her:
```
sudo ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Kopieren Sie snapshot.db/ nach /mnt:
```
sudo cp snapshot.db /mnt/
```
Erstellen Sie ein temporäres Verzeichnis wie backup:
Hinweis: Dies ist nicht erforderlich, wenn bereits ein Sicherungsordner mit den Secrets vorhanden ist.
```
mkdir backup
```
Schließen Sie die Administrator-Steuerungsebene:
```
exit
```

Kopieren Sie die Zertifikate nach backup/:

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

Stellen Sie eine Shell-Verbindung zum Knoten der Administrator-Steuerungsebene her:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Dabei ist [EXTERNAL_IP] die externe IP-Adresse der Administrator-Steuerungsebene, die Sie zuvor ermittelt haben.

Beenden Sie kube-etcd und kube-apiserver.

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

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

Kopieren Sie die Sicherungs-Secrets nach /etc/kubernetes/pki/:
```
sudo cp -r backup/* /etc/kubernetes/pki/
```

Führen Sie etcdctl restore mit Docker aus:

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/"

Starten Sie kube-etcd und kube-apiserver neu.

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

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

Prüfen Sie, ob kube-etcd und kube-apiserver gestartet wurden.
```
sudo crictl ps -a
```
Hinweis: Wenn kube-etcd oder kube-apiserver den Status „Beendet“ hat, befolgen Sie das Verfahren zur Fehlerbehebung bei der Admincluster-Wiederherstellung.
Kopieren Sie /etc/kubernetes/admin.conf in einen .kube-Ordner, damit auf dieses über die Administrator-Workstation zugegriffen werden kann:
```
mkdir -p [HOME]/.kube
```
```
sudo cp -i /etc/kubernetes/admin.conf [HOME]/.kube/config
```
```
sudo chown $(id -u):$(id -g) $HOME/.kube/config
```
Schließen Sie die Administrator-Steuerungsebene:
```
exit
```
Kopieren Sie die neu erstellte kubeconfig-Datei aus dem Administratorknoten:
```
sudo scp -i vsphere_tmp ubuntu@[EXTERNAL_IP]:[HOME]/.kube/config kubeconfig
```
```
sudo chown $(id -u):$(id -g) kubeconfig
```
Dabei gilt:
- [EXTERNAL_IP] ist die externe IP-Adresse der Administrator-Steuerungsebene.
- [HOME] ist das Basisverzeichnis auf dem Administratorknoten.
Jetzt können Sie mit dieser neuen kubeconfig-Datei auf den wiederhergestellten Cluster zugreifen.

Fehlerbehebung bei der Wiederherstellung eines Administratorclusters

Wenn beim Wiederherstellen des Administratorclusters ein Problem auftritt, wenden Sie sich bitte an den Google-Support, um das Problem mit dem Administratorcluster zu beheben.

In der Zwischenzeit können Sie Folgendes prüfen, um das Problem weiter einzugrenzen.

Etcd-Container-ID ermitteln
```
sudo crictl ps -a | grep [ADMIN_ETCD_POD]
```
Dabei ist [ADMIN_ETCD_POD] der Name des etcd-Pods.
Logs aus dem etc-Container prüfen
```
sudo crictl logs [ETCD_CONTAINER_ID]
```
Dabei ist [ETCD_CONTAINER_ID] die ID des etcd-Containers.
Suchen Sie nach den folgenden Logmeldungen, die auf eine verweigerte Berechtigung hinweisen, z. B.

etcdserver: create snapshot directory error:mkdir /var/lib/etcd/member/snap: permission denied
Wenn Meldungen, die auf eine verweigerte Berechtigung hinweisen, angezeigt werden, aktualisieren Sie die Eigentümerschaft von /opt/data/var/lib/etcd/.
```
sudo chown -R 2001:2001 /opt/data/var/lib/etcd/
```
Prüfen Sie, ob kube-etcd und kube-apiserver gestartet wurden.
```
sudo crictl ps
```

Automatische Clustersicherung

Sie können das hier angegebene Skript als Beispiel für die automatische Sicherung Ihrer Cluster verwenden. Beachten Sie, dass das folgende Skript nicht unterstützt wird und nur als Referenz zum Schreiben eines besseren, stabileren und vollständigeren Skripts verwendet werden sollte. Bevor Sie das Skript ausführen, geben Sie Werte für die fünf Variablen am Anfang des Skripts ein.

Setzen Sie BACKUP_DIR auf den Pfad, unter dem Sie die Sicherungen der Administrator- und Nutzerclusters speichern möchten. Dieser Pfad sollte noch nicht vorhanden sein.
Setzen Sie ADMIN_CLUSTER_KUBECONFIG auf den Pfad der kubeconfig-Datei des Administratorclusters.
Setzen Sie USER_CLUSTER_NAMESPACE auf den Namen des Nutzerclusters. Der Name des Nutzerclusters ist ein Namespace im Administratorcluster.
Setzen Sie EXTERNAL_IP auf die VIP, die Sie für den Dienst der Administrator-Steuerungsebene reserviert haben.
Legen Sie für SSH_PRIVATE_KEY den Pfad Ihres SSH-Schlüssels fest.
Wenn Sie ein privates Netzwerk verwenden, setzen Sie JUMP_IP auf die IP-Adresse des Jump-Servers Ihres Netzwerks.

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

Nächste Schritte

Nutzercluster sichern und wiederherstellen
Clusterprobleme diagnostizieren
Erfahren Sie mehr über Auger, einem Open-Source-Tool zum Wiederherstellen einzelner Objekte aus etcd-Sicherungen