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

En esta página, se describe cómo crear y restablecer manualmente las copias de seguridad de los clústeres de administrador y de usuario de GKE On-Prem. En esta página, también se proporciona una secuencia de comandos que puedes usar para crear copias de seguridad de tus clústeres de forma automática.

Debes crear copias de seguridad para la recuperación ante desastres previstos que podrían dañar los secretos y los datos de etcd. Asegúrate de almacenar las copias de seguridad en una ubicación que esté fuera del clúster y que no dependa de su funcionamiento. Si deseas una mayor seguridad, se recomienda que también crees una copia de la copia de seguridad.

Si bien el Pod de eventos de etcd que se ejecuta en cada clúster no es vital para el restablecimiento de un clúster de usuario, puedes seguir un proceso similar para crear una copia de seguridad de este.

Restricciones

• La copia de seguridad de los datos específicos de la aplicación está fuera del alcance de esta función.
• Los secretos son válidos hasta que los rotas de forma manual.
• Las cargas de trabajo que se programan después de crear una copia de seguridad no se restablecen con esa copia de seguridad.
• Por el momento, no puedes restablecer desde actualizaciones fallidas de clústeres.
• Este procedimiento no está diseñado para restablecer un clúster borrado.

Problemas conocidos

Cuando ejecutas comandos sudo, puede que experimentes el siguiente error:

sudo: unable to resolve host gke-admin-master-[CLUSTER_ID]

Si aparece este error, agrega la siguiente línea al archivo /etc/hosts:

127.0.0.1 gke-admin-master-[CLUSTER_ID]

Copias de seguridad de clústeres de usuario

Las copias de seguridad de los clústeres de usuario contienen una instantánea del etcd del clúster de usuario. El etcd de un clúster contiene, entre otros elementos, todos los objetos de Kubernetes y los objetos personalizados necesarios para administrar el estado del clúster. Esta instantánea contiene los datos necesarios para volver a crear los componentes y las cargas de trabajo del clúster.

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

El etcd de un clúster de usuario se almacena en el nodo del plano de control, al que puedes acceder mediante el kubeconfig del clúster de administrador.

Para crear una instantánea del etcd, sigue estos pasos:

1. Conéctate a la shell del contenedor de kube-etcd:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] exec \
   -it -n [USER_CLUSTER_NAME] kube-etcd-0 -c \
   kube-etcd -- 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 particular, pasas un espacio de nombres en el clúster de administrador que lleva el nombre del clúster de usuario.

2. 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=/etcd.local.config/certificates/etcdCA.crt \
   --cert=/etcd.local.config/certificates/etcd.crt --key=/etcd.local.config/certificates/etcd.key \
   snapshot save snapshot.db

3. Sal del contenedor:

   exit

4. Copia la copia de seguridad del contenedor de kube-etcd mediante kubectl cp:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] cp \
   [USER_CLUSTER_NAME]/kube-etcd-0:snapshot.db [DIRECTORY] -c kube-etcd

   En el ejemplo anterior, [RELATIVE_DIRECTORY] es la ruta en la que quieres almacenar la copia de seguridad.

Restablece una copia de seguridad del clúster de usuario

• Antes de restablecer una copia de seguridad, asegúrate de diagnosticar el clúster y resolver los problemas existentes. Restablecer una copia de seguridad en un clúster problemático podría volver a producir o empeorar los problemas. Comunícate con el equipo de asistencia de GKE On-Prem para obtener más asistencia sobre cómo restablecer los clústeres.

• Si creaste un clúster de usuario con alta disponibilidad, debes ejecutar estos pasos una vez por cada miembro del clúster de etcd. Puedes usar la misma instantánea cuando restablezcas cada miembro de etcd. No sigas estos pasos a menos que todos los Pods de etcd estén en un bucle de fallas; esto indica que hay daños en los datos.

Pod de etcd en un bucle de fallas

En las siguientes instrucciones, se explica cómo restablecer una copia de seguridad en los casos en que los datos de etcd de un clúster de usuario se dañaron, y el Pod de etcd se encuentra en un bucle de fallas. Puedes recuperarte si implementas un Pod de etcd en los volúmenes del Pod existente y reemplazas los datos dañados por la copia de seguridad, siempre que el servidor de la API del clúster de usuario se ejecute y pueda programar Pods nuevos.

1. Copia la especificación del Pod de etcd que se encuentra a continuación en un archivo, restore-etcd.yaml, después de propagar los siguientes valores de marcadores de posición:

   • [MEMBER_NUMBER] es el Pod numerado que deseas restablecer.
   • [NODE_NAME] es el nodo en el que se ejecuta el Pod [MEMBER_NUMBER[.
   • [ADMIN_CLUSTER_KUBECONFIG] es el archivo kubeconfig del clúster de administrador.
   • [USER_CLUSTER_NAME] es el nombre del clúster de usuario.

   • [DEFAULT_TOKEN] se usa para la autenticación. Para encontrar este valor, ejecuta el siguiente comando:

     kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] \
     -n [USER_CLUSTER_NAME] get pods kube-etcd-0 \
     -o yaml | grep default-token

   Nota: En el valor image que se muestra a continuación, se supone que usas el registro de gcr.io. Cambia el nombre de la imagen si usas un registro privado.

   restore-etcd.yaml

   apiVersion: v1
   kind: Pod
   metadata:
     labels:
       Component: restore-etcd-[MEMBER_NUMBER]
     name: restore-etcd-0
     namespace: restore-etcd-[MEMBER_NUMBER]
   spec:
     restartPolicy: Never
     containers:
     - command: ["/bin/sh"]
       args: ["-ec", "while :; do echo '.'; sleep 5 ; done"]
       image: gcr.io/gke-on-prem-release/etcd:v3.2.24-1-gke.0
       imagePullPolicy: IfNotPresent
       name: restore-etcd
       terminationMessagePath: /dev/termination-log
       terminationMessagePolicy: File
       volumeMounts:
       - mountPath: /var/lib/etcd
         name: data
       - mountPath: /etcd.local.config/certificates
         name: etcd-certs
       - mountPath: /var/run/secrets/kubernetes.io/serviceaccount
         name: [DEFAULT_TOKEN]
         readOnly: true
     dnsPolicy: ClusterFirst
     hostname: restore-etcd-0
     imagePullSecrets:
     - name: private-registry-creds
     nodeSelector:
       kubernetes.googleapis.com/cluster-name: [USER_CLUSTER_NAME]
       kubernetes.io.hostname: [NODE_NAME]
     priority: 0
     restartPolicy: Always
     schedulerName: default-scheduler
     securityContext: {}
     serviceAccount: default
     serviceAccountName: default
     subdomain: restore-etcd
     terminationGracePeriodSeconds: 30
     tolerations:
     - effect: NoExecute
       key: node.kubernetes.io/not-ready
       operator: Exists
       tolerationSeconds: 300
     - effect: NoExecute
       key: node.kubernetes.io/unreachable
       operator: Exists
       tolerationSeconds: 300
     volumes:
     - name: data
       persistentVolumeClaim:
         claimName: data-kube-etcd-[MEMBER_NUMBER]
     - name: etcd-certs
       secret:
         defaultMode: 420
         secretName: kube-etcd-certs
     - name: [DEFAULT_TOKEN]
       secret:
         defaultMode: 420
         secretName: [DEFAULT_TOKEN]

2. Implementa el Pod:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] \
   -n [USER_CLUSTER_NAME] create -f restore-etcd.yaml

3. Copia el archivo de copia de seguridad de etcd, snapshot.db, en el Pod nuevo. snapshot.db se encuentra en el directorio relativo en el que creaste la copia de seguridad:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] \
   cp [RELATIVE_DIRECTORY]/snapshot.db \
   [USER_CLUSTER_NAME]/restore-etcd-0:snapshot.db

4. Conéctate a la shell del Pod restore-etcd:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] \
   -it -n [USER_CLUSTER_NAME] exec restore-etcd-0 -- bin/sh

5. Ejecuta el siguiente comando para crear una carpeta default.etcd 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

6. Reemplaza los datos de etcd dañados por la copia de seguridad:

   rm -r var/lib/etcd/*; cp -r default.etcd/* var/lib/etcd/

7. Sal del contenedor:

   exit

8. Borra el Pod de etcd con fallas:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] \
   -n [USER_CLUSTER_NAME] delete pod kube-etcd-0

9. Verifica que el Pod de etcd ya no falle.

10. Quita restore-etcd.yaml y borra el Pod restore-etcd:

    rm restore-etcd.yaml;
    kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] \
    -n [USER_CLUSTER_NAME] delete pod restore-etcd-0

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:

1. 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 gke-admin-master

   En el ejemplo anterior, [ADMIN_CLUSTER_KUBECONFIG] es el archivo kubeconfig del clúster de administrador.

2. 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

3. Comprueba si puedes conectarte a la shell del plano de control del administrador mediante esta clave privada:

   ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]

4. Sal del contenedor:

   exit

Crea una copia de seguridad de un clúster del administrador

Puedes crear una copia de seguridad del etcd de un clúster de administrador y de los Secretos del plano de control.

etcd

Para crear una copia de seguridad del etcd del clúster de administrador, sigue estos pasos:

1. Obtén el nombre del Pod de etcd:

   kubectl --kubeconfig [ADMIN_KUBECONFIG] get pods \
   -n kube-system | grep etcd-gke-admin-master

2. 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.

3. 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

4. Sal del contenedor:

   exit

5. 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.

Secretos

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

1. 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.

2. 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

3. Copia los Secretos en el directorio de copia de seguridad local:

   sudo cp -r /etc/kubernetes/pki/* backup/

4. Cambia los permisos de los Secretos de la copia de seguridad:

   sudo chmod -R +rw backup/

5. Sal del contenedor:

   exit

6. 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.

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.

Nota: El clúster de usuario aún puede ejecutar sus cargas de trabajo, incluso si el plano de control del usuario está inactivo. Sin embargo, si un plano de control del usuario está inactivo, no puede programar cargas de trabajo nuevas o actualizadas ni controlar otras fallas del clúster.

1. 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.

2. Conéctate a la shell del plano de control del administrador:

   sudo ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]

3. Copia snapshot.db/ en /mnt:

   sudo cp snapshot.db /mnt/

4. 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

5. Sal del plano de control del administrador:

   exit

6. Copia los certificados en backup/:

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

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

8. 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

9. Copia los Secretos de la copia de seguridad en /etc/kubernetes/pki/:

   sudo cp -r backup/* /etc/kubernetes/pki/

10. 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/"

11. 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

12. Sal del plano de control del administrador:

    exit

13. 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 archivo kubeconfig nuevo para acceder al clúster restaurado.

Secuencia de comandos de copia de seguridad

Puedes usar la secuencia de comandos que se proporciona aquí para crear copias de seguridad automáticas de tus clústeres. Antes de ejecutar la secuencia de comandos, completa los valores de las cinco variables al comienzo de la secuencia.

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.

#!/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 ssh private key - follow steps in documentation

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_snapshot.db $BACKUP_DIR/

# ADMIN CLUSTER BACKUP

# Copy admin certs
ssh -o StrictHostKeyChecking=no -i vsphere_tmp ubuntu@${EXTERNAL_IP} 'sudo chmod -R +rw /etc/kubernetes/pki/*'
scp -o StrictHostKeyChecking=no -r -i vsphere_tmp 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 -o=name | grep etcd | cut -c 5-)
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"

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.

Comportamiento de registro predeterminado

Para gkectl y gkeadm, basta con usar la configuración de registro predeterminada:

• De forma predeterminada, las entradas de registro se guardan de la siguiente manera:

  • Para gkectl, el archivo de registro predeterminado es /home/ubuntu/.config/gke-on-prem/logs/gkectl-$(date).log y el archivo está vinculado con un symlink con el archivo logs/gkectl-$(date).log en el directorio local en el que ejecutas gkectl.
  • Para gkeadm, el archivo de registro predeterminado es logs/gkeadm-$(date).log en el directorio local en el que ejecutas gkeadm.
• Todas las entradas de registro se guardan en el archivo de registro, incluso si no se imprimen en la terminal (cuando --alsologtostderr es false).
• El nivel de verbosidad -v5 (predeterminado) cubre todas las entradas de registro que necesita el equipo de asistencia al cliente.
• El archivo de registro también contiene el comando ejecutado y el mensaje de error.

Recomendamos que envíes el archivo de registro al equipo de asistencia al cliente cuando necesites ayuda.

Especifica una ubicación no predeterminada para el archivo de registro

A fin de especificar una ubicación no predeterminada para el archivo de registro gkectl, usa la marca --log_file. El archivo de registro que especifiques no se vinculará con un symlink con el directorio local.

A fin de especificar una ubicación no predeterminada para el archivo de registro gkeadm, usa la marca --log_file.

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:

1. 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

2. 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.