Os clusters do Anthos no VMware agora são o Google Distributed Cloud (somente software) para VMware. Para mais informações, consulte a visão geral do produto.

Esta página foi traduzida pela API Cloud Translation.

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.

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.
Não use este procedimento para clusters com cluster avançado ativado. Em vez disso, consulte Fazer backup e restaurar clusters avançados com o gkectl.

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

Como fazer backup de um cluster de administrador

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:

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.
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
```
Verifique se é possível entrar no plano de controle do administrador usando esta chave privada:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
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:

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"}'

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.

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

Saia do contêiner:
```
exit
```
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:

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.
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
```
Copie localmente os Secrets para o diretório de backup local:
```
sudo cp -r /etc/kubernetes/pki/* backup/
```
Altere as permissões dos secrets de backup:
```
sudo chmod -R a+rX backup/
```
Saia do nó do plano de controle do administrador:
```
exit
```
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

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.

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.
Coloque um shell no plano de controle do administrador:
```
sudo ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Copie snapshot.db/ para /mnt:
```
sudo cp snapshot.db /mnt/
```
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
```
Saia do plano de controle do administrador:
```
exit
```

Copie os certificados para backup/:

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

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.

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

Copie os Secrets de backup para /etc/kubernetes/pki/:
```
sudo cp -r backup/* /etc/kubernetes/pki/
```

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

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

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.

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

Saia do plano de controle do administrador:
```
exit
```
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.

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.
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.
Procure as seguintes mensagens de registro de permissão negada, como:

etcdserver: create snapshot directory error:mkdir /var/lib/etcd/member/snap: permission denied
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/
```
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.