Crea copias de seguridad de clústeres y restablécelos

En esta página, se describe cómo crear una copia de seguridad y restablecer los clústeres creados con clústeres de Anthos alojados en un equipo físico. Estas instrucciones se aplican a todos los tipos de clústeres compatibles con los clústeres de Anthos alojados en equipos físicos.

Crea una copia de seguridad de un clúster

El proceso de copia de seguridad tiene dos partes. Primero, se realiza una instantánea desde el almacén de etcd. Luego, los certificados de PKI relacionados se guardan en un archivo tar. El almacén de etcd es el almacenamiento de copia de seguridad de Kubernetes para todos los datos del clúster y contiene todos los objetos de Kubernetes y objetos personalizados requeridos para administrar el estado del clúster. Los certificados de PKI se usan para la autenticación con TLS. Estos datos tienen copia de seguridad desde el plano de control del clúster o en uno de los planos de control para una alta disponibilidad (HA).

Te recomendamos crear una copia de seguridad de tus clústeres con regularidad para asegurarte de que los datos de la instantánea sean relativamente actuales. La frecuencia de las copias de seguridad depende de la frecuencia con la que se producen cambios significativos en los clústeres.

Haz una instantánea de almacenamiento de etcd

En los clústeres de Anthos alojados en equipos físicos, un Pod llamado etcd-CONTROL_PLANE_NAME en el espacio de nombres de kube-system ejecuta el etcd para ese plano de control. Para crear una copia de seguridad del almacén de etcd del clúster, realiza los siguientes pasos desde tu estación de trabajo de administrador:

Usa kubectl get po para identificar el Pod de etcd.

kubectl --kubeconfig CLUSTER_KUBECONFIG get po -n kube-system \
    -l 'component=etcd,tier=control-plane'

La respuesta incluye el nombre del Pod de etcd y su estado.

Usa kubectl describe pod para ver los contenedores que se ejecutan en el Pod etcd, incluido el contenedor etcd.
```
kubectl --kubeconfig CLUSTER_KUBECONFIG describe pod ETCD_POD_NAME -n kube-system
```

Ejecuta una shell de Bash en el contenedor de etcd.

kubectl --kubeconfig CLUSTER_KUBECONFIG exec -it \
    ETCD_POD_NAME --container etcd --namespace kube-system \
    -- bin/sh

Desde la shell dentro del contenedor de etcd, usa etcdctl (la versión 3 de la API) para guardar una instantánea, snapshot.db, del almacén de etcd.

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

Reemplaza DATESTAMP por la fecha actual para evitar reemplazar las instantáneas posteriores.

Sal de la shell en el contenedor y ejecuta el siguiente comando para copiar el archivo de instantáneas en la estación de trabajo de administrador.
```
kubectl --kubeconfig CLUSTER_KUBECONFIG cp \
    kube-system/ETCD_POD_NAME:snapshot.db \
    --container etcd snapshot.db
```
Almacena el archivo de instantánea en una ubicación que esté fuera del clúster y no dependa de la operación de este.

Archiva los certificados de PKI

Los certificados para crear una copia de seguridad se encuentran en el directorio /etc/kubernetes/pki del plano de control. Los certificados de PKI, junto con el archivo snapshot.db del almacén de etcd, son necesarios para recuperar un clúster en caso de que el plano de control se interrumpa por completo. Los siguientes pasos crean un archivo tar y contienen los certificados de PKI.

Usa ssh para conectarte al plano de control del clúster como raíz.
```
ssh root@CONTROL_PLANE_NAME
```
En el plano de control, crea un archivo tar, certs_backup.tar.gz, con el contenido del directorio /etc/kubernetes/pki.
```
tar -czvf certs_backup.tar.gz -C /etc/kubernetes/pki .
```
Crea el archivo tar desde el plano de control conserva todos los permisos del archivo de certificado.
Sal del plano de control y, en la estación de trabajo, copia el archivo tar y que contiene los certificados para una ubicación preferida de la estación de trabajo.
```
sudo scp root@CONTROL_PLANE_NAME:certs_backup.tar.gz BACKUP_PATH
```

Restablece un clúster

Restablecer un clúster desde una copia de seguridad es el último recurso y se debe usar cuando un clúster falla de manera catastrófica y no puede regresar al servicio de ninguna otra manera. Por ejemplo, los datos etcd están dañados o el Pod de etcd está en un bucle de falla.

El proceso de restablecimiento del clúster tiene dos partes. En primer lugar, los certificados de PKI se restablecen en el plano de control. A continuación, se restablecen los datos de almacén de etcd.

Restablece certificados de la PKI

Si suponemos que creaste copias de seguridad de certificados PKI como se describe en Archiva los certificados de PKI, en los pasos siguientes, se describe cómo restablecer los certificados del archivo tar a un plano de control.

Copia el archivo tar de certificados de PKI, certs_backup.tar.gz, de la estación de trabajo al plano de control del clúster.
```
sudo scp -r BACKUP_PATH/certs_backup.tar.gz root@CONTROL_PLANE_NAME:~/
```
Usa ssh para conectarte al plano de control del clúster como raíz.
```
ssh root@CONTROL_PLANE_NAME
```
Desde el plano de control, extrae el contenido del archivo tar en el directorio /etc/kubernetes/pki.
```
tar -xzvf certs_backup.tar.gz -C /etc/kubernetes/pki/
```
Sal del plano de control.

Restablece el almacén de etcd

Cuando restableces el almacén de etcd, el proceso depende de si el clúster se ejecuta o no en modo de alta disponibilidad (HA) y, de ser así, de si se conservó o no quórum. Usa la siguiente guía a fin de restablecer el almacén de etcd para una situación de falla de clúster determinada:

Si el clúster con errores no se ejecuta en modo de alta disponibilidad, restablece el almacén de etcd en el plano de control con los siguientes pasos.
Si el clúster se ejecuta en modo de alta disponibilidad y el quórum se conserva, no realices ninguna acción. Siempre que se conserve un quórum, no necesitas restablecer los clústeres con errores.
Si el clúster se ejecuta en modo de alta disponibilidad y se pierde quórum, repite los siguientes pasos a fin de restablecer el almacén de etcd para cada miembro con errores.

Sigue estos pasos de la estación de trabajo para quitar y restablecer el almacén de etcd en un plano de control de un clúster con errores:

Crea un directorio /backup en el directorio raíz del plano de control.
```
ssh root@CONTROL_PLANE_NAME "mkdir /backup"
```
Este paso no es estrictamente obligatorio, pero lo recomendamos. En los siguientes pasos, se supone que creaste un directorio /backup.
Copia el archivo de instantáneas de etcd, snapshot.db, de la estación de trabajo al directorio backup en el plano de control del clúster.
```
sudo scp snapshot.db root@CONTROL_PLANE_NAME:/backup
```
Usa SSH para conectarte al nodo del plano de control del administrador:
```
ssh root@CONTROL_PLANE_NAME
```
Para detener los Pods estáticos de etcd y kube-apiserver, mueve los archivos de manifiesto del directorio /etc/kubernetes/manifests al directorio /backup.
```
sudo mv /etc/kubernetes/manifests/etcd.yaml /backup/etcd.yaml
sudo mv /etc/kubernetes/manifests/kube-apiserver.yaml /backup/kube-apiserver.yaml
```
Quita el directorio de datos de etcd.
```
rm -rf /var/lib/etcd/
```

Ejecuta el restablecimiento de la instantánea etcdctl mediante docker.

sudo docker run --rm -t \
    -v /var/lib:/var/lib \
    -v /etc/kubernetes/pki/etcd:/etc/kubernetes/pki/etcd \
    -v /backup:/backup \
    --env ETCDCTL_API=3 \
    k8s.gcr.io/etcd:3.2.24 etcdctl \
    --cacert=/etc/kubernetes/pki/etcd/ca.crt \
    --cert=/etc/kubernetes/pki/etcd/server.crt \
    --key=/etc/kubernetes/pki/etcd/server.key \
    --data-dir=/var/lib/etcd \
    --name=CONTROL_PLANE_NAME \
    --initial-advertise-peer-urls=https://CONTROL_PLANE_IP:2380 \
    --initial-cluster=CONTROL_PLANE_NAME=https://CONTROL_PLANE_IP:2380 \
    snapshot restore /backup/snapshot.db

Las entradas para --name, --initial-advertise-peer-urls y --initial-cluster se pueden encontrar en el archivo de manifiesto etcd.yaml que se movió al directorio /backup.

Asegúrate de que se haya vuelto a crear /var/lib/etcd y que se cree un miembro nuevo en /var/lib/etcd/member.

Mueve los manifiestos de etcd y kube-apiserver de nuevo al directorio /manifests para que los Pods estáticos puedan reiniciarse.

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

Ejecuta una shell de Bash en el contenedor de etcd.

kubectl --kubeconfig CLUSTER_KUBECONFIG exec -it \
    ETCD_POD_NAME --container etcd --namespace kube-system \
    -- bin/sh

Usa etcdctl para confirmar que el miembro agregado funciona de forma correcta.

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

Si restableces varios miembros con fallas, una vez que se hayan restablecido todos los miembros con fallas, ejecuta el comando con las direcciones IP del plano de control de todos los miembros restablecidos en el campo “--endpoints”.

Por ejemplo:

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

Si se ejecuta de forma correcta para cada extremo, tu clúster debería funcionar bien.