Crea una copia de seguridad de un clúster de administrador y restablécelo

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

Puedes crear un archivo de copia de seguridad para la recuperación ante desastres previstos 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 administrador

Las copias de seguridad de los clústeres de administrador contienen lo siguiente:

Una instantánea del etcd del clúster de administrador
Los Secretos del plano de control del administrador, que son necesarios para la autenticación en los clústeres de usuario y administrador

Completa los siguientes pasos antes de crear una copia de seguridad del clúster de administrador:

Busca la dirección IP externa del clúster de administrador, que se usa para establecer una conexión SSH al plano de control del clúster de administrador:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get nodes -n kube-system -o wide | grep master
```
En el ejemplo anterior, [ADMIN_CLUSTER_KUBECONFIG] es el archivo kubeconfig del clúster de administrador.
Crea una clave SSH llamada vsphere_tmp a partir de la clave privada del clúster de administrador.

Puedes buscar la clave privada en los Secretos de los clústeres de administrador:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get secrets sshkeys -n kube-system -o yaml
```
En el resultado del comando, puedes encontrar la clave privada en el campo vsphere_tmp.

Copia la clave privada en vsphere_tmp:
```
echo "[PRIVATE_KEY]" | base64 -d > vsphere_tmp; chmod 600 vsphere_tmp
```
Comprueba si puedes conectarte a la shell del plano de control del administrador mediante esta clave privada:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Sal del contenedor:
```
exit
```

Crea una copia de seguridad del depósito de etcd del clúster de administrador

Para crearla, sigue estos pasos:

Obtén el nombre del Pod de etcd:

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

Conéctate a la shell del contenedor de kube-etcd del Pod:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG]  exec -it \
    -n kube-system [ADMIN_ETCD_POD] -- bin/sh
```
En el ejemplo anterior, [ADMIN_ETCD_POD] es el nombre del Pod de etcd.

En la shell, usa etcdctl para crear una copia de seguridad llamada snapshot.db en el directorio local:

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

Sal del contenedor:
```
exit
```
Copia la copia de seguridad del contenedor de kube-etcd mediante kubectl cp:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] cp \
kube-system/[ADMIN_ETCD_POD]:tmp/snapshot.db [RELATIVE_DIRECTORY]
```
En el ejemplo anterior, [RELATIVE_DIRECTORY] es la ruta en la que quieres almacenar la copia de seguridad.

Cómo hacer una copia de seguridad de los secretos de un clúster de administrador

Para crear una copia de seguridad de los Secretos del plano de control del administrador, haz lo siguiente:

Usa SSH para conectarte al nodo del plano de control del administrador:
```
ssh -i vsphere_tmp ubuntu@EXTERNAL_IP
```
Reemplaza EXTERNAL_IP por la dirección IP externa del plano de control del administrador, que anotaste antes.
Opcional, pero altamente recomendado: Crea un directorio de copia de seguridad local.

Debes cambiar los permisos de los Secretos de la copia de seguridad para copiarlos del nodo.
```
mkdir backup
```
Copia los Secretos en el directorio de copia de seguridad local:
```
sudo cp -r /etc/kubernetes/pki/* backup/
```
Cambia los permisos de los Secretos de la copia de seguridad:
```
sudo chmod -R a+rX backup/
```
Sal del nodo del plano de control del administrador:
```
exit
```
Ejecuta scp para copiar la carpeta de la copia de seguridad fuera del nodo del plano de control del administrador:
```
sudo scp -r -i vsphere_tmp  ubuntu@EXTERNAL_IP:backup/ RELATIVE_DIRECTORY
```
Reemplaza RELATIVE_DIRECTORY por la ruta en la que deseas almacenar tu copia de seguridad.

Restablece un clúster de administrador

Con el siguiente procedimiento, se vuelve a crear un clúster de administrador con una copia de seguridad y todos los planos de control del usuario que administró cuando se creó la instantánea de etcd.

Ejecuta scp para copiar snapshot.db en el plano de control del administrador:
```
sudo scp -i vsphere_tmp snapshot.db ubuntu@[EXTERNAL_IP]:
```
En el ejemplo anterior, [EXTERNAL_IP] es la dirección IP externa del plano de control que recopilaste antes.
Conéctate a la shell del plano de control del administrador:
```
sudo ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Copia snapshot.db/ en /mnt:
```
sudo cp snapshot.db /mnt/
```
Crea un directorio temporal, como backup:

Nota: No necesitas hacer esto si ya existe una carpeta de copia de seguridad que contiene los Secrets.
```
mkdir backup
```
Sal del plano de control del administrador:
```
exit
```

Copia los certificados en backup/:

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

Conéctate a la shell del nodo del plano de control del administrador:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
En el ejemplo anterior, [EXTERNAL_IP] es la dirección IP externa del plano de control que recopilaste antes.

Detiene kube-etcd y 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 los Secretos de la copia de seguridad en /etc/kubernetes/pki/:
```
sudo cp -r backup/* /etc/kubernetes/pki/
```

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

Reinicia kube-etcd y kube-apiserver.

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

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

Verifica que kube-etcd y kube-apiserver se hayan iniciado.
```
sudo crictl ps -a
```
Nota: Si kube-etcd o kube-apiserver están en el estado de salida, sigue estos pasos para solucionar problemas relacionados con el restablecimiento del administrador.

Copia /etc/kubernetes/admin.conf en una carpeta .kube para que se pueda acceder desde la estación de trabajo de administrador:

mkdir -p [HOME]/.kube

sudo cp -i /etc/kubernetes/admin.conf [HOME]/.kube/config

sudo chown $(id -u):$(id -g) $HOME/.kube/config

Sal del plano de control del administrador:
```
exit
```
Copia el archivo kubeconfig recién generado del nodo de administrador:
```
sudo scp -i vsphere_tmp ubuntu@[EXTERNAL_IP]:[HOME]/.kube/config kubeconfig
```
```
sudo chown $(id -u):$(id -g) kubeconfig
```
Donde:
- [EXTERNAL_IP] es la dirección IP externa del plano de control del administrador.
- [HOME] es el directorio principal del nodo del administrador.
Ahora, puedes usar este nuevo archivo kubeconfig para acceder al clúster restablecido.

Soluciona problemas de restablecimiento de un clúster de administrador

Si tienes problemas para restablecer el clúster de administrador, comunícate con el equipo de Atención al cliente de Google a fin de resolverlo.

Mientras tanto, puedes consultar lo siguiente para solucionar otros problemas.

Busca el ID del contenedor de etcd
```
sudo crictl ps -a | grep [ADMIN_ETCD_POD]
```
En el ejemplo anterior, [ADMIN_ETCD_POD] es el nombre del Pod de etcd.
Examina los registros del contenedor etc.
```
sudo crictl logs [ETCD_CONTAINER_ID]
```
En el ejemplo anterior, [ETCD_CONTAINER_ID] es el ID del contenedor etcd.
Busca los siguientes mensajes de registro de permiso denegado, como

etcdserver: create snapshot directory error:mkdir /var/lib/etcd/member/snap: permission denied
Si se encuentran mensajes de permiso denegado, actualiza la propiedad de /opt/data/var/lib/etcd/.
```
sudo chown -R 2001:2001 /opt/data/var/lib/etcd/
```
Verifica que kube-etcd y kube-apiserver se hayan iniciado.
```
sudo crictl ps
```

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:

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

¿Qué sigue?

Crea una copia de seguridad de un clúster de usuario y restablecerlo
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.