Fazer backup e restaurar um cluster de administrador

Este documento mostra como fazer backup e restaurar o armazenamento etcd para um cluster de administrador criado com o Google Distributed Cloud (somente software) para VMware. Este documento também fornece um script que pode ser usado para fazer backup automático do armazenamento etcd de um cluster. Também é possível fazer backup e restaurar um cluster de administrador usando a ferramenta de linha de comando gkectl.

É possível criar um arquivo de backup para recuperação de potenciais desastres que possam danificar os dados do etcd do cluster. Armazene o arquivo de backup em um local fora do cluster que não dependa da operação dele.

Observação: usar uma ferramenta de backup de terceiros, como a Veeam, para fazer backup de um cluster de administrador não é compatível. Fazer backup do cluster com uma ferramenta de terceiros pode levar a erros imprevistos nas operações do cluster.

Limitações

O procedimento de backup e restauração descrito neste documento tem as seguintes limitações:

• Este procedimento não faz backup de dados específicos do aplicativo.

• Este procedimento não faz backup dos PersistentVolumes.

• As cargas de trabalho programadas após a criação de um backup não são restauradas com esse backup.

• Não é possível restaurar um cluster após uma falha no upgrade.

• Esse procedimento não tem a finalidade de restaurar um cluster excluído.

Aviso: usar um arquivo de backup para restaurar os dados do etcd é o último recurso. Não recomendamos fazer a restauração de um arquivo de backup, a menos que o cluster esteja completamente corrompido. Entre em contato com o Suporte do Google e receba ajuda para decidir a melhor solução.

Para mais informações sobre as limitações, consulte Incompatibilidade de infraestrutura.

Como fazer backup de um cluster de administrador

Observação: um novo recurso de visualização fornece uma maneira mais fácil de fazer backups. Consulte Fazer backup e restaurar um cluster de administrador com gkectl. Use esse método em vez daquele que está descrito nesta seção.

Um backup de cluster de administrador contém os seguintes elementos:

• Um snapshot do etcd do cluster de administrador.
• Os Secrets do plano de controle do administrador, necessários para a autenticação nos clusters de administrador e de usuário.

Conclua as etapas a seguir antes de criar um backup do cluster de administrador:

1. Encontre o endereço IP externo do cluster de administrador, que é usado para fazer o SSH no plano de controle do cluster de administrador:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get nodes -n kube-system -o wide | grep master

   em que [ADMIN_CLUSTER_KUBECONFIG] é o arquivo kubeconfig do cluster de administrador.

2. Crie uma chave SSH chamada vsphere_tmp a partir da chave privada do cluster de administrador.

   É possível encontrar a chave privada nos Secrets dos clusters de administrador:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get secrets sshkeys -n kube-system -o yaml

   Na resposta ao comando, encontre a chave privada no campo vsphere_tmp.

   Copie a chave privada para vsphere_tmp:

   echo "[PRIVATE_KEY]" | base64 -d > vsphere_tmp; chmod 600 vsphere_tmp

3. Verifique se é possível entrar no plano de controle do administrador usando esta chave privada:

   ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
   

4. Saia do contêiner:

   exit

Como fazer backup do armazenamento etcd de um cluster de administrador

Para fazer backup do armazenamento etcd do cluster de administrador:

1. Consiga o nome do pod do etcd:

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

2. Coloque um shell no contêiner kube-etcd do pod:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG]  exec -it \
       -n kube-system [ADMIN_ETCD_POD] -- bin/sh

   em que [ADMIN_ETCD_POD] é o nome do pod etcd.

3. No shell, use etcdctl para criar um backup chamado snapshot.db no diretório 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
   

4. Saia do contêiner:

   exit

5. Copie o backup do contêiner kube-etcd usando kubectl cp:

   kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] cp \
   kube-system/[ADMIN_ETCD_POD]:tmp/snapshot.db [RELATIVE_DIRECTORY]
   

   em que [RELATIVE_DIRECTORY] é um caminho em que você quer armazenar o backup.

Como fazer backup de Secrets de um cluster de administrador

Para fazer backup dos secrets do plano de controle do administrador:

1. Use SSH para se conectar ao nó do plano de controle do administrador:

   ssh -i vsphere_tmp ubuntu@EXTERNAL_IP
   

   Substitua EXTERNAL_IP pelo endereço IP externo do plano de controle de administrador anotado anteriormente.

2. Opcional, mas altamente recomendado: crie um diretório de backup local.

   É necessário alterar as permissões dos Secrets de backup para copiá-los do nó:

   mkdir backup

3. Copie localmente os Secrets para o diretório de backup local:

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

4. Altere as permissões dos secrets de backup:

   sudo chmod -R a+rX backup/

5. Saia do nó do plano de controle do administrador:

   exit

6. Execute scp para copiar a pasta de backup do nó do plano de controle do administrador:

   sudo scp -r -i vsphere_tmp  ubuntu@EXTERNAL_IP:backup/ RELATIVE_DIRECTORY
   

   Substitua RELATIVE_DIRECTORY por um caminho em que você quer armazenar o backup.

Como restaurar um cluster de administrador

Observação: um novo recurso de visualização fornece uma maneira mais fácil de restaurar um cluster de administrador. Consulte Fazer backup e restaurar o cluster de administrador com gkectl.

O procedimento a seguir recria um cluster de administrador armazenado em backup e todos os planos de controle do usuário que ele gerenciou quando o snapshot do etcd foi criado.

Observação: o cluster de usuários ainda pode executar as cargas de trabalho mesmo que o plano de controle do usuário esteja inativo. No entanto, se um plano de controle do usuário estiver inativo, ele não poderá programar cargas de trabalho novas ou atualizadas nem lidar com outras falhas de cluster.

1. Execute scp para copiar snapshot.db para o plano de controle do administrador:

   sudo scp -i vsphere_tmp snapshot.db ubuntu@[EXTERNAL_IP]:

   em que [EXTERNAL_IP] é o endereço IP externo do plano de controle do administrador coletado anteriormente.

2. Coloque um shell no plano de controle do administrador:

   sudo ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
   

3. Copie snapshot.db/ para /mnt:

   sudo cp snapshot.db /mnt/

4. Crie um diretório temporário, como backup:

   Observação: isso não será necessário se já houver uma pasta de backup contendo os Secrets.

   mkdir backup

5. Saia do plano de controle do administrador:

   exit

6. Copie os certificados para backup/:

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

7. Coloque um Shell no nó do plano de controle de administrador:

   ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
   

   em que [EXTERNAL_IP] é o endereço IP externo do plano de controle do administrador coletado anteriormente.

8. Parar kube-etcd e kube-apiserver.

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

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

9. Copie os Secrets de backup para /etc/kubernetes/pki/:

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

10. Execute etcdctl restore com o 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/"

11. Reinicie kube-etcd e kube-apiserver.

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

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

12. Verifique se kube-etcd e kube-apiserver iniciaram.

    sudo crictl ps -a

    Observação: se kube-etcd ou kube-apiserver estiverem com status "exited", siga as instruções em resolver problemas de restauração do administrador.

13. Copie /etc/kubernetes/admin.conf para uma pasta .kube para que ela possa ser acessada pela estação de trabalho do administrador:

    mkdir -p [HOME]/.kube

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

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

14. Saia do plano de controle do administrador:

    exit

15. Copie o arquivo kubeconfig recém-gerado do nó de administrador:

    sudo scp -i vsphere_tmp ubuntu@[EXTERNAL_IP]:[HOME]/.kube/config kubeconfig

    sudo chown $(id -u):$(id -g) kubeconfig

    em que:

    • [EXTERNAL_IP] é o endereço IP externo do plano de controle de administrador.
    • [HOME] é o diretório inicial no nó de administrador.

    Agora é possível usar esse novo arquivo kubeconfig para acessar o cluster restaurado.

Solução de problemas de restauração de um cluster de administrador

Se você encontrar um problema ao restaurar o cluster de administrador, entre em contato com o Suporte do Google para resolvê-lo.

Enquanto isso, você pode verificar os seguintes itens para resolver o problema.

1. Encontre o ID do contêiner do etcd

   sudo crictl ps -a | grep [ADMIN_ETCD_POD]

   em que [ADMIN_ETCD_POD] é o nome do pod etcd.

2. Examine os registros do contêiner do etcd

   sudo crictl logs [ETCD_CONTAINER_ID]

   em que [ETCD_CONTAINER_ID] é o ID do contêiner do etcd.

3. Procure as seguintes mensagens de registro de permissão negada, como:

   etcdserver: create snapshot directory error:mkdir /var/lib/etcd/member/snap: permission denied

4. Se as mensagens de permissão negada forem encontradas, atualize a propriedade de /opt/data/var/lib/etcd/

   sudo chown -R 2001:2001 /opt/data/var/lib/etcd/

5. Verifique se kube-etcd e kube-apiserver iniciaram.

   sudo crictl ps

Backup automático de cluster

É possível usar o script fornecido aqui como um exemplo de como fazer backup dos clusters automaticamente. O script a seguir não é compatível, e só deve ser usado como referência para escrever um script melhor, mais robusto e completo. Antes de executar o script, preencha os valores das cinco variáveis no início do script:

• Defina BACKUP_DIR como o caminho em que você quer armazenar os backups de cluster de administrador e de usuário. Este caminho não pode existir.
• Defina ADMIN_CLUSTER_KUBECONFIG como o caminho do arquivo kubeconfig do cluster de administrador.
• Defina USER_CLUSTER_NAMESPACE como o nome do cluster de usuário. O nome do cluster de usuário é um namespace no cluster de administração.
• Defina EXTERNAL_IP como o VIP que você reservou para o serviço de plano de controle do administrador.
• Defina SSH_PRIVATE_KEY como o caminho da sua chave SSH.
• Se você estiver usando uma rede privada, defina JUMP_IP como o endereço IP do servidor jump da sua rede.

#!/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

A seguir

• Fazer backup e restaurar um cluster de usuários
• Diagnosticar problemas de cluster
• Saiba mais sobre o Augur, uma ferramenta de código aberto para restaurar objetos individuais de backups do etcd.