Esta página foi traduzida pela API Cloud Translation.

Faça uma cópia de segurança e restaure um cluster de administrador

Este documento mostra como fazer uma cópia de segurança e restaurar o armazenamento etcd para um cluster de administrador criado com o Google Distributed Cloud (apenas software) para VMware. Este documento também fornece um script que pode usar para fazer uma cópia de segurança automática da loja etcd de um cluster. Também pode criar uma cópia de segurança e restaurar um cluster de administrador através da ferramenta de linha de comandos gkectl.

Pode criar um ficheiro de cópia de segurança para recuperação de desastres inesperados que possam danificar os dados etcd do cluster. Armazene o ficheiro de cópia de segurança numa localização que esteja fora do cluster e não dependa do funcionamento do cluster.

Limitações

O procedimento de cópia de segurança e restauro descrito neste documento tem as seguintes limitações:

Este procedimento não faz uma cópia de segurança dos dados específicos da aplicação.
Este procedimento não faz uma cópia de segurança dos seus PersistentVolumes.
As cargas de trabalho agendadas após a criação de uma cópia de segurança não são restauradas com essa cópia de segurança.
Não pode restaurar um cluster após uma atualização com falha.
Este procedimento não se destina a restaurar um cluster eliminado.
Não use este procedimento para clusters com a opção cluster avançado ativada. Em alternativa, consulte o artigo Faça uma cópia de segurança e restaure clusters avançados com o gkectl.

Para mais informações sobre as limitações, consulte o artigo Incompatibilidade da infraestrutura.

Fazer uma cópia de segurança de um cluster de administrador

Uma cópia de segurança do cluster de administrador contém o seguinte:

Um instantâneo do etcd do cluster de administrador.
Segredos do plano de controlo do administrador, que são necessários para a autenticação nos clusters de administrador e de utilizador.

Conclua os passos seguintes antes de criar uma cópia de segurança do cluster de administrador:

Encontre o endereço IP externo do cluster de administrador, que é usado para estabelecer ligação SSH ao plano de controlo do cluster de administrador:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get nodes -n kube-system -o wide | grep master
```
onde [ADMIN_CLUSTER_KUBECONFIG] é o ficheiro kubeconfig do cluster de administrador.
Crie uma chave SSH denominada vsphere_tmp a partir da chave privada do cluster de administrador.

Pode encontrar a chave privada nos segredos dos clusters de administrador:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] get secrets sshkeys -n kube-system -o yaml
```
Na saída do comando, pode encontrar 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 consegue aceder ao plano de controlo de administrador através desta chave privada:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
Saia do contentor:
```
exit
```

Fazer uma cópia de segurança da loja etcd de um cluster de administrador

Para fazer uma cópia de segurança do armazenamento etcd do cluster de administrador:

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

Aceda ao shell do contentor 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.

Na shell, use etcdctl para criar uma cópia de segurança com o nome 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 contentor:
```
exit
```
Copie a cópia de segurança do contentor kube-etcd com kubectl cp:
```
kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] cp \
kube-system/[ADMIN_ETCD_POD]:tmp/snapshot.db [RELATIVE_DIRECTORY]
```
onde [RELATIVE_DIRECTORY] é um caminho onde quer armazenar a sua cópia de segurança.

Fazer uma cópia de segurança dos segredos de um cluster de administrador

Para fazer uma cópia de segurança dos segredos do plano de controlo do administrador:

Use SSH para estabelecer ligação ao nó do plano de controlo do administrador:
```
ssh -i vsphere_tmp ubuntu@EXTERNAL_IP
```
Substitua EXTERNAL_IP pelo endereço IP externo do plano de controlo do administrador, que anotou anteriormente.
Opcional, mas altamente recomendado: crie um diretório de cópia de segurança local.

Tem de alterar as autorizações dos segredos de cópia de segurança para os copiar do nó.
```
mkdir backup
```
Copie localmente os segredos para o diretório de cópias de segurança local:
```
sudo cp -r /etc/kubernetes/pki/* backup/
```
Altere as autorizações dos segredos de cópia de segurança:
```
sudo chmod -R a+rX backup/
```
Saia do nó do plano de controlo de administrador:
```
exit
```
Execute scp para copiar a pasta de cópia de segurança para fora do nó do plano de controlo do administrador:
```
sudo scp -r -i vsphere_tmp  ubuntu@EXTERNAL_IP:backup/ RELATIVE_DIRECTORY
```
Substitua RELATIVE_DIRECTORY por um caminho onde quer armazenar a sua cópia de segurança.

Restaurar um cluster de administrador

O procedimento seguinte recria um cluster de administrador com uma cópia de segurança e todos os planos de controlo do utilizador que geriu quando foi criada a respetiva cópia instantânea do etcd.

Execute scp para copiar snapshot.db para o plano de controlo do administrador:
```
sudo scp -i vsphere_tmp snapshot.db ubuntu@[EXTERNAL_IP]:
```
onde [EXTERNAL_IP] é o endereço IP externo do plano de controlo do administrador, que recolheu anteriormente.

Aceda ao plano de controlo do administrador:

sudo ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]

Copiar snapshot.db/ para /mnt:
```
sudo cp snapshot.db /mnt/
```
Crie um diretório temporário, como backup:

Nota: não precisa de o fazer se já existir uma pasta de cópia de segurança com os segredos.
```
mkdir backup
```
Saia do plano de controlo de administração:
```
exit
```

Copie os certificados para backup/:

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

Aceda ao nó do plano de controlo do administrador:
```
ssh -i vsphere_tmp ubuntu@[EXTERNAL_IP]
```
onde [EXTERNAL_IP] é o endereço IP externo do plano de controlo do administrador, que recolheu 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 segredos de cópia de segurança para /etc/kubernetes/pki/:
```
sudo cp -r backup/* /etc/kubernetes/pki/
```

Corrida etcdctl restore:

ETCDCTL_API=3 sudo etcdctl snapshot restore /backup/snapshot.db
sudo rm -r /var/lib/etcd/*
sudo mv /default.etcd/member/ /var/lib/etcd/

Reinicie o kube-etcd e o 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 foram iniciados.
```
sudo crictl ps -a
```
Nota: se kube-etcd ou kube-apiserver estiverem no estado de saída Siga os passos para resolver problemas de restauro do administrador.

Copie /etc/kubernetes/admin.conf para uma pasta .kube para que possa aceder a partir da 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 controlo de administração:
```
exit
```
Copie o ficheiro 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
```
where:
- [EXTERNAL_IP] é o endereço IP externo do plano de controlo do administrador.
- [HOME] é o diretório principal no nó de administração.
Agora, pode usar este novo ficheiro kubeconfig para aceder ao cluster restaurado.

Resolução de problemas de um restauro de cluster de administrador

Se tiver um problema ao restaurar o cluster de administrador, tem de contactar o Apoio técnico da Google para resolver o problema com o cluster de administrador.

Entretanto, pode verificar o seguinte para resolver o problema.

Encontre o ID do contentor etcd
```
sudo crictl ps -a | grep [ADMIN_ETCD_POD]
```
em que [ADMIN_ETCD_POD] é o nome do pod etcd.
Examine os registos do contentor etc
```
sudo crictl logs [ETCD_CONTAINER_ID]
```
onde [ETCD_CONTAINER_ID] é o ID do contentor etcd.
Procure as seguintes mensagens de registo de autorização recusada, como

etcdserver: create snapshot directory error:mkdir /var/lib/etcd/member/snap: permission denied
Se forem encontradas mensagens de autorização recusada, 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 foram iniciados.
```
sudo crictl ps
```

Cópia de segurança automática do cluster

Pode usar o script apresentado aqui como exemplo de como fazer automaticamente uma cópia de segurança dos seus clusters. Tenha em atenção que o seguinte script não é suportado e deve ser usado apenas 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 para o caminho onde quer armazenar as cópias de segurança dos clusters de administrador e de utilizador. Este caminho não deve existir.
Defina ADMIN_CLUSTER_KUBECONFIG para o caminho do ficheiro kubeconfig do cluster de administrador
Defina USER_CLUSTER_NAMESPACE para o nome do cluster de utilizadores. O nome do cluster de utilizadores é um espaço de nomes no cluster de administrador.
Defina EXTERNAL_IP para o VIP que reservou para o serviço do plano de controlo do administrador.
Defina SSH_PRIVATE_KEY para o caminho da sua chave SSH.
Se estiver a usar uma rede privada, defina JUMP_IP para o endereço IP do servidor de encaminhamento 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

O que se segue?

Faça uma cópia de segurança e restaure um cluster de utilizadores
Diagnostique problemas de clusters
Saiba mais sobre o augur, uma ferramenta de código aberto para restaurar objetos individuais a partir de cópias de segurança do etcd.