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

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

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

Advertencia: El uso de un archivo de copia de seguridad para restablecer los datos etcd es el último recurso. No recomendamos restablecer desde un archivo de copia de seguridad, a menos que el clúster esté dañado por completo. Comunícate con Atención al cliente de Google para obtener ayuda a fin de tomar la mejor decisión.

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

Los pasos de copia de seguridad que sigues dependen de si Controlplane V2 está habilitado en el clúster de usuario. Cuando se habilita Controlplane V2, el plano de control del clúster de usuario se ejecuta en el clúster de usuario. Cuando Controlplane V2 no está habilitado, el plano de control del clúster de usuario se ejecuta en uno o más nodos en el 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.

Cubecepción

1. Obtén una shell en el 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 usuario.

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

3. En la shell, ingresa exit para salir de ella.

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

Plano de control V2

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

   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 para clústeres con alta disponibilidad. Para la copia de seguridad, cualquier Pod etcd debería funcionar.

2. Obtén una shell en el 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 tomó del paso anterior.

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

4. En la shell, ingresa exit para salir de ella.

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

6. 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 para el nodo del plano de control.
   • NODE_EXTERNAL_IP es la dirección IP del nodo del plano de control del usuario desde donde deseas que se copien los secretos.
   Nota: Para los clústeres con alta disponibilidad, copia los secretos de todos los nodos del plano de control del usuario siguiendo las instrucciones.

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 alojado en VMware para obtener más ayuda con el restablecimiento de tus 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.

Cubecepción

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.

1. Busca el nombre del Secret que usó etcd en el clúster de usuario:

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG -n USER_CLUSTER_NAME \
      get secrets | grep kube-etcd-certs
   

2. Copia el siguiente manifiesto del Pod en un archivo llamado etcd-utility.yaml. Reemplaza lo siguiente:

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

   • GKE_ON_PREM_VERSION: la versión del clúster en la que deseas realizar el restablecimiento etcd (por ejemplo, 1.5.0-gke.0).

   • KUBE_ETCD_SECRET_NAME: es el nombre del secreto que usa etcd en el clúster de usuarios, a partir de 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
   

3. Implementa el Pod de utilidad:

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
     create -f etcd-utility.yaml --namespace USER_CLUSTER_NAME
   

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

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

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

7. En la shell, borra los datos etcd antiguos:

   rm -r var/lib/etcd/*
   

8. En la shell, copia los datos etcd restablecidos a su ubicación permanente:

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

9. En la shell, ingresa exit para salir de ella.

10. Borra el Pod de etcd con fallas:

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

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

12. Borra el Pod de utilidad:

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

13. Quita etcd-utility.yaml del directorio actual:

    rm etcd-utility.yaml
    

Plano de control V2

Puedes restablecer los datos de etcd uno a la vez mediante la implementación de un contenedor de etcd temporal que reemplace los datos dañados por la copia de seguridad.

1. Obtén una shell en el nodo del plano de control del usuario:

   ssh -i NODE_NAME.key ubuntu@NODE_EXTERNAL_IP
   

2. En la shell, detén el servidor de la API de Kubernetes y el servidor de etcd:

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

3. En la shell, ingresa exit para salir.

4. Ejecuta scp para copiar el archivo de copia de seguridad snapshot.db y los secretos en el nodo del 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
   

5. En la shell, usa snapshot.db para restablecer los datos etcd:

   sudo docker run --rm -t \
   -v /opt/data/var/lib:/var/lib \
   -v /etc/kubernetes/pki/etcd:/etc/kubernetes/pki/etcd \
   -v /tmp:/tmp \
   --env ETCDCTL_API=3 \
   gcr.io/gke-on-prem-release/etcd-util:GKE_ON_PREM_VERSION 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
   

   Donde:

   • GKE_ON_PREM_VERSION es la versión de GKE Enterprise que se usa como etiqueta de imagen
   • NODE_NAME es el nombre del nodo en el que se realiza el restablecimiento.
   • NODE_IP_ADDRESS es la IP de dicho nodo.

6. Agrega la marca - --initial-cluster-state=new en el archivo de manifiesto de etcd en el comando container.

   Ejemplo:

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

7. En la shell, inicia los servidores kube-apiserver y etcd:

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

8. En la shell, ingresa exit para salir.

Nota: Si los Pods events-etcd están en estado CrashLoopBackOff, agrega la marca - --initial-cluster-state=new y reinicia los Pods. Los eventos no se sincronizarán y perderás los eventos almacenados previamente.

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

Cubecepción

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

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

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

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

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

3. Recupera el nombre de la imagen de contenedor de los Pods de etcd.

Implementa los Pods de utilidad

Importante: Realiza los pasos de esta sección para cada uno de los Pods de etcd.

1. Recuerda el nombre del Pod de etcd y el nombre del nodo en el que se ejecuta el Pod.

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

En el manifiesto anterior, se describe un Pod de utilidad que ejecutas de forma temporal para restablecer datos etcd.

1. Crea el Pod de utilidad en el clúster de administrador:

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG apply -f etcd-utility-MEMBER_NUMBER.yaml
   

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

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

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

5. En la shell, borra los datos etcd antiguos:

   rm -r var/lib/etcd/*
   

6. En la shell, copia los datos etcd restablecidos a su ubicación permanente:

   cp -r kube-etcd-MEMBER_NUMBER.etcd/* var/lib/etcd/
   

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

8. En la shell, ingresa exit para salir de ella.

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

1. Reinicia los Pods en el StatefulSet kube-etcd:

   kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG rollout restart statefulset \
   --namespace USER_CLUSTER_NAME kube-etcd
   

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

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

4. Restablece el PDB para el servidor de la API de Kubernetes:

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

Plano de control V2

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 alta disponibilidad, hay tres nodos en el clúster de usuario que funcionan como plano de control del 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 tendrías 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

Importante: Sigue los pasos de las siguientes secciones para cada uno de los nodos de CP del clúster de usuario.

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

   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
   etcd-xxx       ...   xxx
   etcd-yyy       ...   yyy
   etcd-zzz       ...   zzz
   

2. Toma nota de los nombres del Pod y de los nombres del nodo del plano de control para usarlos más adelante.

   Observa que cada Pod de etcd se llama etcd-xxx con un nombre de nodo. Esto se debe a que, en Controlplane V2, los Pods de etcd se ejecutan como un Pod estático.

Preparando para restablecer

1. Ejecuta scp para copiar el archivo de copia de seguridad snapshot.db en todos los nodos del plano de control del usuario:

   scp -i NODE_NAME.key ~/snapshot.db ubuntu@NODE_EXTERNAL_IP:/tmp/
   

2. Copia los secretos en el nodo del plano de control del usuario respectivo:

   chmod a+rw ~/pki_*
   scp -ri NODE_NAME.key ~/pki_NODE_NAME/* ubuntu@NODE_EXTERNAL_IP:/opt/data/etc/kubernetes/pki/
   

3. Obtén una shell en el nodo del plano de control del usuario:

   ssh -i NODE_NAME.key ubuntu@NODE_EXTERNAL_IP
   

Realiza el restablecimiento

1. Recuerda el nombre del Pod de etcd y el nombre del nodo en el que se ejecuta el Pod.

2. En la shell, detén el servidor de la API de Kubernetes y el servidor de etcd en todos los nodos del plano de control del usuario:

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

3. En la shell, usa snapshot.db para restablecer los datos de etcd en todos los nodos del plano de control del usuario:

   sudo docker run --rm -t \
   -v /opt/data/var/lib:/var/lib \
   -v /etc/kubernetes/pki/etcd:/etc/kubernetes/pki/etcd \
   -v /tmp:/tmp \
   --env ETCDCTL_API=3 \
   gcr.io/gke-on-prem-release/etcd-util:GKE_ON_PREM_VERSION 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
   

   Donde:

   • GKE_ON_PREM_VERSION es la versión de GKE Enterprise que se usa como etiqueta de imagen
   • NODE_NAME es el nombre del nodo en el que se realiza el restablecimiento.
   • NODE_IP_ADDRESS es la IP de dicho nodo.
   • Completa el NODE1, NODE2, NODE3 y el IP de sus respectivos nodos para la marca --initial-cluster. También puedes obtenerlo desde el manifiesto de etcd.

4. Agrega la marca - --initial-cluster-state=existing en el archivo de manifiesto de etcd en el comando container.

   Ejemplo:

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

Reinicia componentes

1. En la shell, inicia los servidores kube-apiserver y etcd en todos los nodos del plano de control del usuario:

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

2. En la shell, ingresa exit para salir.

3. Verifica que kube-apiserver y etcd se ejecuten en todos los nodos del plano de control del usuario:

   kubectl get pod --kubeconfig USER_CLUSTER_KUBECONFIG \
   -n kube-system -l tier=control-plane
   

Nota: Si los Pods events-etcd están en estado CrashLoopBackOff, agrega la marca - --initial-cluster-state=new y reinicia los Pods. Los eventos no se sincronizarán y perderás los eventos almacenados previamente.

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:

Cubecepción

• 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 ${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

Plano de control V2

• 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_KUBECONFIG en la ruta de acceso de tu clúster de usuario kubeconfig.
• 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_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

Verifica el restablecimiento

Para verificar que el clúster se restableció correctamente, ejecuta gkectl analyze cluster.

¿Qué sigue?

• Crea una copia de seguridad de un clúster de administrador y restablécelo
• 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.