Se usó la API de Cloud Translation para traducir esta página.

Crea una copia de seguridad de un clúster de usuario y restablecerlo

En este documento, se muestra cómo crear una copia de seguridad y restablecer el depósito de etcd de un clúster de usuario. En esta página, también se proporciona una secuencia de comandos que puedes usar para crear una copia de seguridad automática del almacenamiento de etcd de un clúster.

Puedes crear un archivo de copia de seguridad para la recuperación ante desastres imprevistos que podrían dañar los datos etcd del clúster. Almacena el archivo de copia de seguridad en una ubicación que esté fuera del clúster y no dependa de la operación de este.

Limitaciones

Este procedimiento no crea una copia de seguridad de los datos específicos de la aplicación.
Este procedimiento no crea una copia de seguridad de los PersistentVolumes.
Las cargas de trabajo que se programan después de crear una copia de seguridad no se restablecen con esa copia de seguridad.
No puedes restablecer un clúster después de realizar una actualización con errores.
Este procedimiento no está diseñado para restablecer un clúster borrado.

Crea una copia de seguridad de un clúster de usuario

Una copia de seguridad de un clúster de usuario es una instantánea del depósito de etcd del clúster de usuario. En el depósito de etcd, están todos los objetos de Kubernetes y los objetos personalizados necesarios para administrar el estado del clúster. En esta instantánea, están los datos necesarios para volver a crear los componentes y las cargas de trabajo del clúster.

Los pasos de copia de seguridad que sigas dependen de si el plano de control V2 está habilitado en el clúster de usuario. Cuando el plano de control V2 está habilitado, el plano de control del clúster de usuario se ejecuta en el clúster de usuario. Cuando el plano de control V2 no está habilitado, el plano de control del clúster de usuario se ejecuta en uno o más nodos del clúster de administrador, que se conoce como kubeception.

Ejecuta el siguiente comando para determinar si el clúster tiene habilitado el plano de control V2:

kubectl get onpremuserclusters --kubeconfig USER_CLUSTER_KUBECONFIG \
  -n kube-system -o jsonpath='{.items[0].spec.enableControlplaneV2}' && echo

Si el resultado es true, sigue los pasos de Plano de control V2 para crear una copia de seguridad del clúster. De lo contrario, sigue los pasos de Kubeception.

Kubeception

Obtén una shell en el contenedor kube-etcd:
```
kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG exec -it \
 kube-etcd-0 -c kube-etcd -n USER_CLUSTER_NAME \
 -- /bin/sh
```
Donde:
- ADMIN_CLUSTER_KUBECONFIG es el archivo kubeconfig del clúster de administrador.
- USER_CLUSTER_NAME es el nombre del clúster de usuario.

En la shell, en el directorio /tmp, crea una copia de seguridad llamada 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 /tmp/snapshot.db

En la shell, ingresa exit para salir de ella.

Copia /tmp/snapshot.db del contenedor kube-etcd al directorio actual:

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

Plano de control V2

Obtén el nombre del Pod de etcd:

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

Donde:

USER_CLUSTER_KUBECONFIG es el archivo kubeconfig del clúster de usuario.

Ejemplo:

NAME          READY   STATUS    RESTARTS   AGE
etcd-uc1-cp1  1/1     Running   0          38m
etcd-uc1-cp2  1/1     Running   0          37m
etcd-uc1-cp3  1/1     Running   0          38m

Ten en cuenta que puede haber varios Pods etcd; por ejemplo, 3 para los clústeres con alta disponibilidad. Para la copia de seguridad, cualquier Pod etcd debería funcionar.

Obtén una shell en el contenedor etcd:
```
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG exec -it \
 POD_NAME -c etcd -n kube-system -- /bin/sh
```
Donde:
- POD_NAME es el nombre del Pod de etcd que se tomó del paso anterior.

En la shell, crea un archivo de copia de seguridad llamado snapshot.db:

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

En la shell, ingresa exit para salir de ella.

Copia snapshot.db del contenedor etcd en el directorio principal de la estación de trabajo:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG \
 cp POD_NAME:/tmp/snapshot.db ~/snapshot.db \
 -c etcd -n kube-system

Copia los secretos del directorio de PKI:
```
ssh -i NODE_NAME.key ubuntu@NODE_EXTERNAL_IP
sudo chmod -R 0644 /etc/kubernetes/pki/*
sudo chmod 0755 /etc/kubernetes/pki/etcd
exit
scp -ri NODE_NAME.key ubuntu@NODE_EXTERNAL_IP:/etc/kubernetes/pki ~/pki_NODE_NAME
```
Donde:
- NODE_NAME es el archivo que contiene la clave SSH para el nodo del plano de control.
- NODE_EXTERNAL_IP es la dirección IP del nodo del plano de control del usuario desde el que deseas que se copien los secretos.
Nota: Para los clústeres de HA, copia los secretos de todos los nodos del plano de control del usuario según las instrucciones.

Restablece un clúster de usuario a partir de una copia de seguridad (sin alta disponibilidad)

Antes de usar un archivo de copia de seguridad para restablecer el depósito de etcd del clúster de usuario, diagnostica tu clúster y resuelve los problemas existentes. El uso de una copia de seguridad para restablecer un clúster problemático puede volver a crear o empeorar los problemas. Comunícate con el equipo de asistencia al cliente de GKE en VMware para obtener más ayuda con el restablecimiento de tus clústeres.

En las siguientes instrucciones, se explica cómo usar un archivo de copia de seguridad para restablecer un clúster de usuario en los casos en que los datos etcd del clúster se dañaron y el Pod de etcd del clúster se encuentra en un bucle de fallas.

Kubeception

Para restablecer los datos etcd, implementa un Pod de utilidad que reemplace los datos dañados por la copia de seguridad. El servidor de la API del clúster de administrador debe estar en ejecución, y el programador del clúster de administrador debe poder programar Pods nuevos.

Busca el nombre del Secret que usó etcd en el clúster de usuario:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG -n USER_CLUSTER_NAME \
   get secrets | grep kube-etcd-certs

Copia el siguiente manifiesto del Pod en un archivo llamado etcd-utility.yaml. Reemplaza lo siguiente:

NODE_NAME es el nodo en el que se ejecuta el Pod kube-etcd-0.
ADMIN_CLUSTER_KUBECONFIG es el archivo kubeconfig del clúster de administrador.
USER_CLUSTER_NAME es el nombre del clúster de usuario.
GKE_ON_PREM_VERSION: la versión del clúster en la que deseas realizar el restablecimiento etcd (por ejemplo, 1.5.0-gke.0).
KUBE_ETCD_SECRET_NAME: es el nombre del secreto que usa etcd en el clúster de usuarios, a partir de kube-etcd-certs.

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_SECRET_NAME

Implementa el Pod de utilidad:

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

Copia snapshot.db del directorio actual al directorio raíz del Pod de utilidad:

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

Obtén una shell en el contenedor etcd-utility:

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

En el directorio raíz de la shell, ejecuta el siguiente comando para crear una carpeta nueva que contenga la copia de seguridad:

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

En la shell, borra los datos etcd antiguos:
```
rm -r var/lib/etcd/*
```
En la shell, copia los datos etcd restablecidos a su ubicación permanente:
```
cp -r default.etcd/* var/lib/etcd/
```
En la shell, ingresa exit para salir de ella.

Borra el Pod de etcd con fallas:

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

Verifica que el Pod de etcd ya no falle.

Borra el Pod de utilidad:

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

Quita etcd-utility.yaml del directorio actual:
```
rm etcd-utility.yaml
```

Plano de control V2

Puedes restablecer los datos de etcd uno a la vez mediante la implementación de un contenedor de etcd temporal que reemplace los datos dañados por la copia de seguridad.

Obtén una shell en el nodo del plano de control del usuario:
```
ssh -i NODE_NAME.key ubuntu@NODE_EXTERNAL_IP
```

En la shell, detén el servidor de la API de Kubernetes y el servidor de etcd:

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

En la shell, ingresa exit para salir.

Ejecuta scp para copiar los secretos y el archivo de copia de seguridad snapshot.db en el nodo del plano de control del usuario:

scp -i NODE_NAME.key ~/snapshot.db ubuntu@NODE_EXTERNAL_IP:/tmp/

chmod a+rw pki/
scp -ri NODE_NAME.key ~/pki_NODE_NAME ubuntu@NODE_EXTERNAL_IP:/etc/kubernetes/pki

En la shell, usa snapshot.db para restablecer los datos etcd:

sudo docker run --rm -t \
-v /opt/data/var/lib:/var/lib \
-v /etc/kubernetes/pki/etcd:/etc/kubernetes/pki/etcd \
-v /tmp:/tmp \
--env ETCDCTL_API=3 \
gcr.io/gke-on-prem-release/etcd-util:GKE_ON_PREM_VERSION etcdctl \
--cacert=/etc/kubernetes/pki/etcd/ca.crt \
--cert=/etc/kubernetes/pki/etcd/server.crt \
--key=/etc/kubernetes/pki/etcd/server.key \
--data-dir=/opt/data/var/lib/etcd \
--name=NODE_NAME \
--initial-advertise-peer-urls=https://NODE_IP_ADDRESS:2380 \
--initial-cluster=NODE_NAME=https://NODE_IP_ADDRESS:2380 \
snapshot restore /tmp/snapshot.db

Donde:

GKE_ON_PREM_VERSION es la versión de GKE Enterprise que se usa como etiqueta de imagen.
NODE_NAME es el nombre del nodo en el que se realiza el restablecimiento.
NODE_IP_ADDRESS es la IP de dicho nodo.

Agrega la marca - --initial-cluster-state=new en el archivo de manifiesto de etcd que aparece en el comando del contenedor.

Ejemplo:
```
containers:
      - command:
        - etcd
        ...
        - --initial-cluster-state=new
        ...
```

En la shell, inicia los servidores kube-apiserver y etcd:

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

En la shell, ingresa exit para salir.

Restablece un clúster de usuario a partir de una copia de seguridad (con alta disponibilidad)

Kubeception

En esta sección, se muestra cómo restablecer los datos etcd de un clúster de usuario con alta disponibilidad (HA).

Para un clúster de usuario con HA, hay tres nodos en el clúster de administrador que funcionan como planos de control para el clúster de usuario. Cada uno de esos nodos ejecuta un Pod de etcd que conserva datos de etcd en un volumen de almacenamiento.

Si dos de los Pods de etcd están en buen estado y los datos de los volúmenes de almacenamiento asociados están intactos, no es necesario usar un archivo de copia de seguridad. Eso se debe a que aún tienes un quórum de etcd.

En el caso poco frecuente de que dos de los volúmenes de almacenamiento de etcd tengan datos dañados, debes usar un archivo de copia de seguridad para restablecer los datos de etcd.

Para realizar los pasos de esta sección, ya debes haber creado un archivo snapshot.db como se describe en Crea una copia de seguridad de un clúster de usuario.

Enumera los Pods de etcd y los nodos

Enumera los Pods de etcd que administran el depósito de etcd para el clúster de usuario. Los Pods se ejecutan en el clúster de administrador:
```
kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG get pods --namespace USER_CLUSTER_NAME \
--output wide | grep kube-etcd
```
En el resultado, se muestran los Pods de etcd y los nodos en los que se ejecutan los Pods. Los nodos que se muestran en el resultado son nodos del clúster de administrador que funcionan como planos de control para el clúster de usuario:
```
NAME              ...   NODE
kube-etcd-0       ...   xxx
kube-etcd-1       ...   yyy
kube-etcd-2       ...   zzz
```
Toma nota de los nombres del Pod y de los nombres del nodo del plano de control para usarlos más adelante.

Ten en cuenta que cada Pod de etcd se llama kube-etcd junto con un número. Este número se llama número de miembro del Pod. Identifica al Pod como un miembro en particular del clúster de etcd que conserva los datos del objeto del clúster de usuario. En esta guía, se usa el marcador de posición MEMBER_NUMBER para hacer referencia al número de miembro del Pod de etcd.

Además, observa que cada Pod del clúster de etcd se ejecuta en su propio nodo.

Prepárate para implementar los Pods de utilidad

Guarda un manifiesto de PodDisruptionBudget (PDB) para el servidor de la API de Kubernetes del clúster de usuario. Luego, borra el 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

Detén el servidor de la API de Kubernetes y el Deployment de mantenimiento de etcd. Esto garantiza que ningún componente use etcd durante la restauración:

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

Recupera el nombre de la imagen de contenedor de los Pods de etcd.

Implementa los Pods de utilidad

Recuerda el nombre del Pod de etcd y el nombre del nodo en el que se ejecuta el Pod.
Guarda el siguiente manifiesto del Pod en el directorio actual en un archivo llamado 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_SECRET_NAME

En el manifiesto anterior, se describe un Pod de utilidad que ejecutas temporalmente para restablecer los datos etcd.

Crea el Pod de utilidad en el clúster de administrador:

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

Copia el archivo de copia de seguridad, snapshot.db, en el directorio raíz del Pod de utilidad:

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

Obtén una shell en el contenedor etcd-utility del Pod de utilidad:

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

En el directorio raíz de la shell, usa snapshot.db para restablecer los datos 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

Con el comando anterior, se almacenaron los datos etcd en el directorio /kube-etcd-MEMBER_NUMBER.etcd.

En la shell, borra los datos etcd antiguos:
```
rm -r var/lib/etcd/*
```
En la shell, copia los datos etcd restablecidos a su ubicación permanente:
```
cp -r kube-etcd-MEMBER_NUMBER.etcd/* var/lib/etcd/
```
En la shell, quita el directorio temporal etcd y el archivo de copia de seguridad:
```
rm -R kube-etcd-MEMBER_NUMBER.etcd/
rm snapshot.db
```
En la shell, ingresa exit para salir de ella.

Borra el Pod de utilidad:

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

Reinicia componentes

Ahora que implementaste y borraste los Pods de utilidad, debes reiniciar algunos componentes del clúster.

Reinicia los Pods en el StatefulSet kube-etcd:

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

Inicia los servidores de la API de Kubernetes para el clúster de usuario:

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

Inicia el Deployment de mantenimiento del etcd para el clúster de usuario:

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

Restablece el PDB para el servidor de la API de Kubernetes:

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

Plano de control V2

En esta sección, se muestra cómo restablecer los datos etcd para un clúster de usuario con alta disponibilidad (HA).

Para un clúster de usuario con alta disponibilidad, hay tres nodos en el clúster de usuario que funcionan como plano de control para el clúster de usuario. Cada uno de esos nodos ejecuta un Pod de etcd que conserva datos de etcd en un volumen de almacenamiento.

En el caso poco frecuente de que dos de los volúmenes de almacenamiento de etcd tengan datos dañados, debes usar un archivo de copia de seguridad para restablecer los datos de etcd.

Para realizar los pasos de esta sección, debes haber creado un archivo snapshot.db como se describe en Crea una copia de seguridad de un clúster de usuario.

Enumera los Pods de etcd y los nodos

Enumera los Pods de etcd y sus respectivos nodos:
```
kubectl get pod --kubeconfig USER_CLUSTER_KUBECONFIG \
 -n kube-system -l component=etcd,tier=control-plane -o wide
```
En el resultado, se muestran los Pods de etcd y los nodos en los que se ejecutan los Pods. Los nodos que se muestran en el resultado son nodos del clúster de administrador que funcionan como planos de control para el clúster de usuario:
```
NAME           ...   NODE
etcd-xxx       ...   xxx
etcd-yyy       ...   yyy
etcd-zzz       ...   zzz
```
Toma nota de los nombres del Pod y de los nombres del nodo del plano de control para usarlos más adelante.

Ten en cuenta que cada Pod de etcd tiene el nombre etcd-xxx y se le agrega un nombre de nodo. Esto se debe a que, en Controlplane V2, los Pods de etcd se ejecutan como un Pod estático.

Preparando el restablecimiento

Ejecuta scp para copiar el archivo de copia de seguridad snapshot.db en todos los nodos del plano de control del usuario:
```
scp -i NODE_NAME.key ~/snapshot.db ubuntu@NODE_EXTERNAL_IP:/tmp/
```

Copia los Secrets en el nodo del plano de control del usuario correspondiente:

chmod a+rw ~/pki_*
scp -ri NODE_NAME.key ~/pki_NODE_NAME/* ubuntu@NODE_EXTERNAL_IP:/opt/data/etc/kubernetes/pki/

Obtén una shell en el nodo del plano de control del usuario:
```
ssh -i NODE_NAME.key ubuntu@NODE_EXTERNAL_IP
```

Cómo realizar el restablecimiento

Recuerda el nombre del Pod de etcd y el nombre del nodo en el que se ejecuta el Pod.
En la shell, detén el servidor de la API de Kubernetes y el servidor de etcd en todos los nodos del plano de control del usuario:
```
sudo mv /etc/kubernetes/manifests/kube-apiserver.yaml /etc/kubernetes/manifests/etcd.yaml ~
```

En la shell, usa snapshot.db para restablecer los datos etcd en todos los nodos del plano de control del usuario:

sudo docker run --rm -t \
-v /opt/data/var/lib:/var/lib \
-v /etc/kubernetes/pki/etcd:/etc/kubernetes/pki/etcd \
-v /tmp:/tmp \
--env ETCDCTL_API=3 \
gcr.io/gke-on-prem-release/etcd-util:GKE_ON_PREM_VERSION etcdctl \
--cacert=/etc/kubernetes/pki/etcd/ca.crt \
--cert=/etc/kubernetes/pki/etcd/server.crt \
--key=/etc/kubernetes/pki/etcd/server.key \
--data-dir=/opt/data/var/lib/etcd \
--name=NODE_NAME \
--initial-advertise-peer-urls=https://NODE_IP_ADDRESS:2380 \
--initial-cluster=NODE1=https://NODE1_IP:2380,NODE2=https://NODE2_IP:2380,NODE3=https://NODE3_IP:2380 \
snapshot restore /tmp/snapshot.db

Donde:

GKE_ON_PREM_VERSION es la versión de GKE Enterprise que se usa como etiqueta de imagen.
NODE_NAME es el nombre del nodo en el que se realiza el restablecimiento.
NODE_IP_ADDRESS es la IP de dicho nodo.
Completa los campos NODE1, NODE2, NODE3 y IP de su respectivo nodo para la marca --initial-cluster. También puedes obtenerlo del manifiesto de etcd.

Agrega la marca - --initial-cluster-state=existing en el archivo de manifiesto de etcd que aparece en el comando del contenedor.

Ejemplo:
```
containers:
      - command:
        - etcd
        ...
        - --initial-cluster-state=existing
        ...
```

Reinicia componentes

En la shell, inicia los servidores kube-apiserver y etcd en todos los nodos del plano de control del usuario:
```
sudo mv ~/etcd.yaml ~/kube-apiserver.yaml /etc/kubernetes/manifests/
```
En la shell, ingresa exit para salir.

Verifica que kube-apiserver y etcd se ejecuten en todos los nodos del plano de control del usuario:

kubectl get pod --kubeconfig USER_CLUSTER_KUBECONFIG \
-n kube-system -l tier=control-plane

Copia de seguridad automática de clúster

Puedes usar la secuencia de comandos que aparece aquí como ejemplo para crear copias de seguridad automáticas de los clústeres. Ten en cuenta que la siguiente secuencia de comandos no es compatible y solo debe usarse como referencia para escribir una secuencia de comandos más eficaz, completa y sólida. Antes de ejecutar la secuencia de comandos, completa los valores de las cinco variables al comienzo de la secuencia:

Kubeception

Configura BACKUP_DIR en la ruta en la que deseas almacenar las copias de seguridad de los clústeres de administrador y de usuario. Esta ruta no debería existir.
Configura ADMIN_CLUSTER_KUBECONFIG en la ruta del archivo kubeconfig del clúster de administrador.
Configura USER_CLUSTER_NAMESPACE en el nombre del clúster de usuario. El nombre del clúster de usuario es un espacio de nombres en el clúster de administrador.
Configura EXTERNAL_IP según la VIP que reservaste para el servicio del plano de control del administrador.
Configura SSH_PRIVATE_KEY en la ruta de acceso de tu Clave SSH.
Si usas una red privada, configura JUMP_IP en la dirección IP del servidor de salto de la red.

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

Plano de control V2

Configura BACKUP_DIR en la ruta en la que deseas almacenar las copias de seguridad de los clústeres de administrador y de usuario. Esta ruta no debería existir.
Configura ADMIN_CLUSTER_KUBECONFIG en la ruta del archivo kubeconfig del clúster de administrador.
Configura USER_CLUSTER_KUBECONFIG en la ruta de acceso del kubeconfig de tu clúster de usuario.
Configura EXTERNAL_IP según la VIP que reservaste para el servicio del plano de control del administrador.
Configura SSH_PRIVATE_KEY en la ruta de acceso de tu Clave SSH.
Si usas una red privada, configura JUMP_IP en la dirección IP del servidor de salto de la red.

#!/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_KUBECONFIG=""          # path to user cluster kubeconfig
EXTERNAL_IP=""                      # admin control plane node external ip - follow steps in documentation
SSH_PRIVATE_KEY=""                  # path to 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
user_etcd=$(kubectl --kubeconfig=${USER_CLUSTER_KUBECONFIG} get pods -n kube-system -l component=etcd,tier=control-plane -ojsonpath='{$.items[0].metadata.name}{"\n"}')
kubectl --kubeconfig=${USER_CLUSTER_KUBECONFIG} exec -it -n kube-system ${user_etcd} -c 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/server.crt --key=/etc/kubernetes/pki/etcd/server.key snapshot save /tmp/${user_etcd}_snapshot.db"
kubectl --kubeconfig=${USER_CLUSTER_KUBECONFIG} cp kube-system/${user_etcd}:/tmp/${user_etcd}_snapshot.db $BACKUP_DIR/${user_etcd}_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 /tmp/${admin_etcd}_snapshot.db"
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} cp -n kube-system ${admin_etcd}:/tmp/${admin_etcd}_snapshot.db $BACKUP_DIR/${admin_etcd}_snapshot.db

Verifica el restablecimiento

Para verificar que el clúster se haya restablecido correctamente, ejecuta gkectl diagnose cluster.

¿Qué sigue?

Crea una copia de seguridad de un clúster de administrador y restablécelo
Obtén más información para diagnosticar problemas de clústeres.
Obtén más información sobre augur, una herramienta de código abierto para restablecer objetos individuales a partir de copias de seguridad de etcd.