Versión 1.4. Esta versión ya no es compatible como se describe en la política de compatibilidad de versiones de Anthos. Para obtener los últimos parches y actualizaciones de vulnerabilidades de seguridad, exposiciones y problemas que afectan a clústeres de Anthos alojados en VMware (GKE On-Prem), actualiza a una versión compatible. Puedes encontrar la versión más reciente aquí.

Versiones disponibles

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

En esta página, se muestra cómo crear una copia de seguridad y restablecer el depósito de etcd de un clúster. En esta página, 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.

Determina la imagen del contenedor para los Pods de etcd del clúster de usuario

En algunos de los pasos de esta guía, se requiere que conozcas la imagen de contenedor de los Pods de etcd del clúster de usuario. Usa los siguientes pasos para determinar la imagen de contenedor:

Visualiza el Pod kube-etcd-0:

kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG get pod kube-etcd-0 \
    --namespace USER_CLUSTER_NAME --output yaml

Puedes ver la imagen del contenedor en el resultado. Por ejemplo:

apiVersion: v1
kind: Pod
...
spec:
  containers:
    ...
    image: gcr.io/gke-on-prem-release/etcd:v3.3.19-0-gke.0

Toma nota de la imagen de contenedor para usarla más adelante. En esta guía, se usa el marcador de posición ETCD_CONTAINER_IMAGE para hacer referencia a esta imagen.

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.

Para crear una instantánea del depósito de etcd, sigue estos pasos:

Obtén una shell en el contenedor kube-etcd:
```
kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG exec -it \
   kube-etcd-0 --container kube-etcd --namespace 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 el directorio raíz de la shell, 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 snapshot.db

En la shell, ingresa exit para salir de ella.

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

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

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 On-Prem para obtener más ayuda sobre cómo restablecer los 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.

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.

Copia el siguiente manifiesto del Pod en un archivo llamado etcd-utility.yaml. Reemplaza estos marcadores de posición por valores:

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.
ETCD_CONTAINER_IMAGE es la imagen de contenedor para el Pod kube-etcd-0.

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: ETCD_CONTAINER_IMAGE
    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-certs

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

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

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 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, 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       ...   node-xxx
kube-etcd-1       ...   node-yyy
kube-etcd-2       ...   node-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

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

Implementa los Pods de utilidad

Sigue los pasos de esta sección para cada uno de tus Pods de etcd.

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: ETCD_CONTAINER_IMAGE
    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-certs

El manifiesto anterior describe un Pod de utilidad que ejecutas de forma temporal para restablecer 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 restart rollout 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

Copias de seguridad del 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_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_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_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_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 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]:snapshot.db [RELATIVE_DIRECTORY]
```
En el ejemplo anterior, [RELATIVE_DIRECTORY] es la ruta en la que quieres almacenar la 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 es necesario que lo hagas si ya hay una carpeta de copia de seguridad que contiene los secretos.
```
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.
Ejecuta kubeadm reset. Esto detiene todo lo que esté en ejecución en el clúster de administrador y borra todos los datos de etcd y los Secretos en /etc/kubernetes/pki/:
```
sudo kubeadm reset --ignore-preflight-errors=all
```
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 'k8s.gcr.io/etcd-amd64:3.1.12' /bin/sh -c "etcdctl snapshot restore '/backup/snapshot.db'; mv /default.etcd/member/ /var/lib/etcd/"

Ejecuta kubeadm init. Este comando reutiliza todos los Secretos de la copia de seguridad y reinicia etcd con la instantánea restaurada:
```
sudo kubeadm init --config /etc/kubernetes/kubeadm_config.yaml --ignore-preflight-errors=DirAvailable--var-lib-etcd
```
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
```
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.

Crea una copia de seguridad de los Secrets de un clúster de administrador

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

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.
Crea un directorio de copia de seguridad local. Esto es opcional, pero se recomienda. 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 +rw backup/
```
Sal del contenedor:
```
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]
```
En el ejemplo anterior, [RELATIVE_DIRECTORY] es la ruta en la que quieres almacenar la copia de seguridad.

Secuencia de comandos de copia de seguridad

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 la clave SSH que creaste cuando configuraste la estación de trabajo de administrador.
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

Soluciona problemas

Para obtener más información, consulta Soluciona problemas.

Diagnostica problemas de clústeres mediante `gkectl`

Usa los comandos gkectl diagnose para identificar los problemas de clústeres y compartir la información de un clúster con Google. Consulta Diagnostica problemas de clústeres.

Ejecuta comandos de `gkectl` de forma detallada

-v5

Registra errores de `gkectl` en `stderr`

--alsologtostderr

Ubica los registros de `gkectl` en la estación de trabajo de administrador

Incluso si no pasas las marcas de depuración, puedes ver los registros de gkectl en el siguiente directorio de la estación de trabajo de administrador:

/home/ubuntu/.config/gke-on-prem/logs

Ubica los registros de la API de clúster en el clúster de administrador

Si una VM no se inicia después de que se inicia el plano de control de administrador, puedes intentar depurarla mediante la inspección de los registros de los controladores de la API de clúster en el clúster de administrador:

Encuentra el nombre del Pod de controladores de la API de clúster en el espacio de nombres kube-system, en el que [ADMIN_CLUSTER_KUBECONFIG] es la ruta de acceso al archivo kubeconfig del clúster de administrador:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] -n kube-system get pods | grep clusterapi-controllers
```
Abre los registros del Pod, en los que [POD_NAME] es el nombre del Pod. De manera opcional, usa grep o una herramienta similar para buscar errores:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] -n kube-system logs [POD_NAME] vsphere-controller-manager
```

¿Qué sigue?

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.