Esta página se ha traducido con Cloud Translation API.

Crear copias de seguridad de un clúster de usuarios y restaurarlo

En este documento se muestra cómo crear copias de seguridad y restaurar el almacén etcd de un clúster de usuario creado con Google Distributed Cloud (solo software) para VMware. En esta página también se proporciona una secuencia de comandos que puedes usar para crear automáticamente una copia de seguridad del almacén etcd de un clúster.

Puedes crear un archivo de copia de seguridad para recuperarte de desastres inesperados que puedan dañar los datos de etcd de tu clúster. Almacena el archivo de copia de seguridad en una ubicación que esté fuera del clúster y que no dependa del funcionamiento del clúster.

Limitaciones

Este procedimiento no crea copias de seguridad de datos específicos de la aplicación.
Este procedimiento no crea copias de seguridad de tus PersistentVolumes.
Las cargas de trabajo programadas después de crear una copia de seguridad no se restauran con esa copia.
No puedes restaurar un clúster después de que falle una actualización.
Este procedimiento no está diseñado para restaurar un clúster eliminado.
No utilices este procedimiento en clústeres con la opción Clúster avanzado habilitada. En su lugar, consulta Crear y restaurar una copia de seguridad de clústeres avanzados con gkectl.

Para obtener más información sobre las limitaciones, consulta Incompatibilidad de la infraestructura.

Crear una copia de seguridad de un clúster de usuarios

Una copia de seguridad de un clúster de usuarios es una instantánea del almacén etcd del clúster de usuarios. El almacén etcd contiene todos los objetos de Kubernetes y los objetos personalizados necesarios para gestionar el estado del clúster. La instantánea contiene los datos necesarios para recrear los componentes y las cargas de trabajo del clúster.

Los pasos de la copia de seguridad que debes seguir dependen de si Controlplane V2 está habilitado en el clúster de usuario. Cuando Controlplane V2 está habilitado, el plano de control del clúster de usuarios se ejecuta en el propio clúster de usuarios. Si Controlplane V2 no está habilitado, el plano de control del clúster de usuarios se ejecuta en uno o varios nodos del clúster de administrador, lo que se conoce como kubeception.

Ejecuta el siguiente comando para determinar si el clúster tiene habilitado Controlplane 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 Controlplane V2 para crear una copia de seguridad del clúster. De lo contrario, sigue los pasos de Kubeception.

Kubeception

Accede a una shell del 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 usuarios.

En tu 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 tu shell, introduce exit para salir del shell.

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

Controlplane 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 usuarios.

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 en el caso de los clústeres de alta disponibilidad). Para la copia de seguridad, debería funcionar cualquier pod etcd.

Accede a una shell del 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 ha obtenido en el paso anterior.

En tu 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 tu shell, introduce exit para salir del shell.

Copia snapshot.db del contenedor etcd al 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 la 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 del nodo del plano de control.
- NODE_EXTERNAL_IP es la dirección IP del nodo del plano de control de usuario desde el que quieres copiar los secretos.
Nota: En el caso de los clústeres de alta disponibilidad, copia los secretos de todos los nodos del plano de control de usuario siguiendo las instrucciones.

Restaurar un clúster de usuarios a partir de una copia de seguridad (sin alta disponibilidad)

Antes de usar un archivo de copia de seguridad para restaurar el almacén etcd de tu clúster de usuarios, diagnostica el clúster y resuelve los problemas que haya. Si usas una copia de seguridad para restaurar un clúster que tiene problemas, es posible que se vuelvan a crear o que se agraven los problemas. Ponte en contacto con el Google Cloud equipo de Asistencia para obtener más ayuda para restaurar tus clústeres.

En las siguientes instrucciones se explica cómo usar un archivo de copia de seguridad para restaurar un clúster de usuario en los casos en los que los datos de etcd del clúster se hayan dañado y el pod de etcd del clúster de usuario esté en un bucle de fallos.

Kubeception

Para restaurar los datos de etcd, puedes implementar un pod de utilidad que sobrescriba los datos dañados con 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 nuevos pods.

Busca el nombre del Secret que usa 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 de Pod en un archivo llamado etcd-utility.yaml. Sustituye lo siguiente:

NODE_NAME: el nodo en el que se ejecuta el pod kube-etcd-0.
ADMIN_CLUSTER_KUBECONFIG: el archivo kubeconfig del clúster de administrador.
USER_CLUSTER_NAME: el nombre del clúster de usuarios.
GKE_ON_PREM_VERSION: la versión del clúster en el que quieres realizar la restauración de etcd (por ejemplo, 1.5.0-gke.0).
KUBE_ETCD_SECRET_NAME: el nombre del secreto que usa etcd en el clúster de usuario, que empieza por 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

Despliega 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

Accede a una shell del contenedor etcd-utility:

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

En tu shell, en el directorio raíz, ejecuta el siguiente comando para crear una carpeta 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 tu shell, elimina los datos antiguos de etcd:
```
rm -r var/lib/etcd/*
```
En tu shell, copia los datos de etcd restaurados en su ubicación permanente:
```
cp -r default.etcd/* var/lib/etcd/
```
En tu shell, introduce exit para salir del shell.

Elimina el pod de etcd que falla:

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

Comprueba que el pod de etcd ya no falle.

Elimina el Pod de la compañía eléctrica:

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

Controlplane V2

Puedes restaurar los datos de etcd de uno en uno implementando un contenedor etcd temporal que sobrescriba los datos dañados con 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 el shell, detén el servidor de la API de Kubernetes y el servidor etcd:

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

En el shell, escribe exit para salir.

Ejecuta scp para copiar el archivo de copia de seguridad snapshot.db y los secretos en el nodo de 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 el shell, usa snapshot.db para restaurar los datos de etcd:

ETCDCTL_API=3 sudo 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

Haz los cambios siguientes:

NODE_NAME: el nombre del nodo en el que se está realizando la restauración
NODE_IP_ADDRESS: la dirección IP del nodo en cuestión.

Añade la marca - --initial-cluster-state=new en el archivo de manifiesto de etcd, en el comando del contenedor.

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

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

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

En el shell, escribe exit para salir.

Restaurar un clúster de usuarios a partir de una copia de seguridad (alta disponibilidad)

Kubeception

En esta sección se muestra cómo restaurar los datos de etcd de un clúster de usuarios de alta disponibilidad.

En el caso de un clúster de usuarios de alta disponibilidad, hay tres nodos en el clúster de administradores que actúan como planos de control del clúster de usuarios. Cada uno de esos nodos ejecuta un pod de etcd que mantiene los 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. Esto se debe a que todavía tienes un quórum de etcd.

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

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

Listar los pods y los nodos de etcd

Lista los pods de etcd que gestionan el almacén de etcd de tu clúster de usuarios. Estos 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
```
La salida muestra 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 actúan como planos de control de tu clúster de usuario:
```
NAME              ...   NODE
kube-etcd-0       ...   xxx
kube-etcd-1       ...   yyy
kube-etcd-2       ...   zzz
```
Anota los nombres de los pods y los nombres de los nodos del plano de control para más adelante.

Observa que cada pod de etcd se llama kube-etcd seguido de un número. Este número se denomina número de miembro del pod. Identifica el pod como un miembro concreto del clúster de etcd que contiene los datos del objeto de tu 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.

También puedes observar que cada pod de tu clúster de etcd se ejecuta en su propio nodo.

Preparar el despliegue de los pods de utilidad

Guarda un manifiesto de PodDisruptionBudget (PDB) para el servidor de la API de Kubernetes del clúster de usuario. A continuación, elimina el archivo 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. De esta forma, se asegura de que ningún componente utilice 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

Recuerda el nombre de la imagen de contenedor de tus pods de etcd.

Desplegar 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 de 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

El manifiesto anterior describe un pod de utilidad que se ejecuta temporalmente para restaurar los datos de etcd.

Crea el pod de utilidad en tu 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 de tu Pod de utilidad:

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

Obtén un 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 tu shell, en el directorio raíz, usa snapshot.db para restaurar los datos de 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

El comando anterior ha almacenado los datos de etcd en el directorio /kube-etcd-MEMBER_NUMBER.etcd.

En tu shell, elimina los datos antiguos de etcd:
```
rm -r var/lib/etcd/*
```
En tu shell, copia los datos de etcd restaurados en su ubicación permanente:
```
cp -r kube-etcd-MEMBER_NUMBER.etcd/* var/lib/etcd/
```
En tu shell, elimina el directorio etcd temporal y el archivo de copia de seguridad:
```
rm -R kube-etcd-MEMBER_NUMBER.etcd/
rm snapshot.db
```
En tu shell, introduce exit para salir del shell.

Elimina el Pod de la compañía eléctrica:

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

Reiniciar componentes

Ahora que has desplegado y eliminado tus pods de utilidad, debes reiniciar algunos componentes del clúster.

Reinicia los pods del 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 de tu clúster de usuario:

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

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

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

Restaura el PDB del servidor de la API de Kubernetes:

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

Controlplane V2

En esta sección se muestra cómo restaurar los datos de etcd de un clúster de usuarios de alta disponibilidad.

En un clúster de usuarios de alta disponibilidad, hay tres nodos que actúan como plano de control del clúster de usuarios. Cada uno de esos nodos ejecuta un pod de etcd que mantiene los datos de etcd en un volumen de almacenamiento.

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

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

Listar los pods y los nodos de etcd

Lista 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
```
La salida muestra 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 actúan como planos de control de tu clúster de usuario:
```
NAME           ...   NODE
etcd-xxx       ...   xxx
etcd-yyy       ...   yyy
etcd-zzz       ...   zzz
```
Anota los nombres de los pods y los nombres de los nodos del plano de control para más adelante.

Observa que cada pod de etcd se llama etcd-xxx seguido del nombre de un nodo. Esto se debe a que, en Controlplane V2, los pods de etcd se ejecutan como pods estáticos.

Preparando la restauración

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

Copia los secretos en el nodo de 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
```

Realizar la restauración

Recuerda el nombre del pod de etcd y el nombre del nodo en el que se ejecuta el pod.
En el shell, detén el servidor de la API de Kubernetes y el servidor 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 el shell, usa snapshot.db para restaurar los datos de etcd en todos los nodos del plano de control del usuario:
```
ETCDCTL_API=3 sudo 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
```
Haz los cambios siguientes:
- NODE_NAME: el nombre del nodo en el que se está realizando la restauración.
- NODE_IP_ADDRESS: la dirección IP del nodo en cuestión.
- Rellena los campos NODE1, NODE2 y NODE3, así como los campos NODE1_IP, NODE2_IP y NODE3_IP de su nodo correspondiente para la marca --initial-cluster. También puedes obtenerlo del manifiesto de etcd.
Añade la marca - --initial-cluster-state=existing en el archivo de manifiesto de etcd, en el comando del contenedor.

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

Reiniciar componentes

En la shell, inicia los servidores kube-apiserver y etcd en todos los nodos del plano de control de usuario:
```
sudo mv ~/etcd.yaml ~/kube-apiserver.yaml /etc/kubernetes/manifests/
```
En el shell, escribe exit para salir.
Verifica que kube-apiserver y etcd se estén ejecutando en todos los nodos del plano de control de usuario:
```
kubectl get pod --kubeconfig USER_CLUSTER_KUBECONFIG \
-n kube-system -l tier=control-plane
```

Copia de seguridad automática de clústeres

Puedes usar la secuencia de comandos que se indica aquí como ejemplo de cómo crear copias de seguridad de tus clústeres automáticamente. Ten en cuenta que la siguiente secuencia de comandos no es compatible y solo debe usarse como referencia para escribir una secuencia de comandos mejor, más sólida y completa. Antes de ejecutar la secuencia de comandos, rellena los valores de las cinco variables que aparecen al principio:

Kubeception

Define BACKUP_DIR en la ruta en la que quieras almacenar las copias de seguridad del clúster de administrador y de usuario. Esta ruta no debería existir.
Define ADMIN_CLUSTER_KUBECONFIG como la ruta del archivo kubeconfig del clúster de administrador.
Define USER_CLUSTER_NAMESPACE con el nombre de tu clúster de usuario. El nombre de tu clúster de usuarios es un espacio de nombres del clúster de administrador.
Asigna EXTERNAL_IP al VIP que has reservado para el servicio del plano de control de administrador.
Asigna SSH_PRIVATE_KEY a la ruta de tu clave SSH.
Si usas una red privada, asigna a JUMP_IP la dirección IP del servidor de salto de tu 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

Controlplane V2

Define BACKUP_DIR en la ruta en la que quieras almacenar las copias de seguridad del clúster de administrador y de usuario. Esta ruta no debería existir.
Define ADMIN_CLUSTER_KUBECONFIG como la ruta del archivo kubeconfig del clúster de administrador.
Define USER_CLUSTER_KUBECONFIG como la ruta del archivo kubeconfig de tu clúster de usuario.
Asigna EXTERNAL_IP al VIP que has reservado para el servicio del plano de control de administrador.
Asigna SSH_PRIVATE_KEY a la ruta de tu clave SSH.
Si usas una red privada, asigna a JUMP_IP la dirección IP del servidor de salto de tu 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

Verificar la restauración

Para verificar que el clúster se ha restaurado correctamente, ejecuta gkectl diagnose cluster.

Siguientes pasos

Crear y restaurar una copia de seguridad de un clúster de administrador
Diagnosticar problemas de clústeres
Consulta información sobre auger, una herramienta de código abierto para restaurar objetos individuales a partir de copias de seguridad de etcd.

Crear copias de seguridad de un clúster de usuarios y restaurarlo Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Limitaciones

Crear una copia de seguridad de un clúster de usuarios

Kubeception

Controlplane V2

Restaurar un clúster de usuarios a partir de una copia de seguridad (sin alta disponibilidad)

Kubeception

Controlplane V2

Restaurar un clúster de usuarios a partir de una copia de seguridad (alta disponibilidad)

Kubeception

Listar los pods y los nodos de etcd

Preparar el despliegue de los pods de utilidad

Desplegar los pods de utilidad

Reiniciar componentes

Controlplane V2

Listar los pods y los nodos de etcd

Preparando la restauración

Realizar la restauración

Reiniciar componentes

Copia de seguridad automática de clústeres

Kubeception

Controlplane V2

Verificar la restauración

Siguientes pasos

Crear copias de seguridad de un clúster de usuarios y restaurarlo