Faça backup e restaure clusters de carga de trabalho usando o Velero

Artigo
06/04/2024

Aplica-se a: AKS no Azure Stack HCI 22H2, AKS no Windows Server

Este artigo descreve como instalar e usar o Velero para fazer backup e restaurar a carga de trabalho e os clusters de destino usando o Armazenamento de Blobs do Azure ou o armazenamento MinIO no AKS habilitado pelo Azure Arc.

Velero é uma ferramenta padrão da comunidade de código aberto para fazer backup e restaurar objetos de cluster do Kubernetes e volumes persistentes. Ele suporta vários provedores de armazenamento para armazenar seus backups. Se um cluster Kubernetes de destino AKS Arc falhar e não conseguir se recuperar, você poderá usar um backup Velero para restaurar seu conteúdo e objetos internos da API para um novo cluster.

Se não quiser armazenar seus backups no Armazenamento de Blobs do Azure, você pode usar o MinIO com Velero. Este artigo descreve como instalar e configurar o Velero para usar o Armazenamento de Blobs do Azure ou instalar e configurar o Velero para usar o armazenamento MinIO.

Nota

Velero não suporta oficialmente o Microsoft Windows. Nos testes, a equipe do Velero conseguiu fazer backup apenas de aplicativos sem monitoração de estado do Windows. Restic Não havia suporte para integração e backups de aplicativos com monitoração de estado ou volumes persistentes.

Pré-requisitos

Preencha estes pré-requisitos antes de começar a implantação do Velero:

Instale a CLI do Azure.
Instalar Chocolateyo . Você pode usar Chocolatey para instalar o cliente Velero, que inclui a CLI do Velero, em uma máquina Windows.

Instalar o Velero com o Armazenamento de Blobs do Azure

Os procedimentos nesta seção descrevem como instalar o Velero e usar o Armazenamento de Blob do Azure para backups. Se você não quiser armazenar seus backups no Azure, vá para Instalar o Velero com armazenamento MiniO.

Abra o PowerShell como um Administrador.
Faça logon no Azure usando a CLI do Azure:
```
az login --use-device-code   
```
Instale a CLI do Velero executando o seguinte comando:

Nota

O sinalizador --use-restic não é mais suportado na versão velero 1.10+, para poder usar o sinalizador versão 1.9.x é necessário

choco install velero

Se necessário, altere para a assinatura do Azure que você deseja usar para os backups.

Por padrão, o Velero armazena backups na mesma assinatura do Azure que suas VMs e discos e não permite que você restaure backups para um grupo de recursos em uma assinatura diferente. Para habilitar backups e restaurações entre assinaturas, especifique uma assinatura a ser usada para seus backups. Pode ignorar este passo se já tiver a subscrição que pretende utilizar para as suas cópias de segurança.

Mude para a subscrição que pretende utilizar para as suas cópias de segurança:
1. Use o nome da assinatura para encontrar a ID da assinatura:
```
$AZURE_BACKUP_SUBSCRIPTION_NAME="<NAME_OF_TARGET_SUBSCRIPTION>"
$AZURE_BACKUP_SUBSCRIPTION_ID=$(az account list --query="[?name=='$AZURE_BACKUP_SUBSCRIPTION_NAME'].id | [0]" -o tsv)
```
2. Em seguida, altere a assinatura:
```
az account set -s $AZURE_BACKUP_SUBSCRIPTION_ID
```
Crie uma conta de armazenamento do Azure e um contêiner de blob.

Quando você usa o Armazenamento de Blob do Azure para backups, o Velero requer uma conta de armazenamento e um contêiner de blob para armazenar os backups. O exemplo a seguir mostra a conta de armazenamento criada em um novo grupo de recursos Velero_Backups .

Você deve criar a conta de armazenamento com um ID globalmente exclusivo que possa ser usado no DNS. O script de exemplo usa o uuidgen aplicativo para gerar aleatoriamente um nome exclusivo. Você pode usar qualquer método, desde que o nome siga as regras de nomenclatura do Azure para contas de armazenamento.

A conta de armazenamento é criada com recursos de criptografia em repouso (usando chaves gerenciadas pela Microsoft) e é configurada para permitir acesso somente por conexões HTTPS.

Para criar a conta de armazenamento e o contêiner de blob, siga estas etapas:
1. Crie um grupo de recursos para a conta de armazenamento de backup. Altere os diretórios para o local de sua preferência, se necessário, e execute os seguintes comandos:
```
$AZURE_BACKUP_RESOURCE_GROUP="Velero_Backups"
az group create -n $AZURE_BACKUP_RESOURCE_GROUP --location WestUS
```
2. Crie a conta de armazenamento:
```
$AZURE_STORAGE_ACCOUNT_ID="<NAME_OF_ACCOUNT_TO_ASSIGN>"

az storage account create --name $AZURE_STORAGE_ACCOUNT_ID --resource-group $AZURE_BACKUP_RESOURCE_GROUP --sku Standard_GRS --encryption-services blob --https-only true --kind BlobStorage --access-tier Hot
```
3. Crie um contêiner de blob:
```
$BLOB_CONTAINER="velero"
az storage container create -n $BLOB_CONTAINER --public-access off --account-name $AZURE_STORAGE_ACCOUNT_ID
```
  O exemplo usa um contêiner de blob chamado velero. Você pode usar um nome diferente, de preferência exclusivo para um único cluster Kubernetes.
Crie uma entidade de serviço:
1. Obtenha a ID da subscrição e a ID do inquilino para a sua conta do Azure:
```
$AZURE_SUBSCRIPTION_ID=(az account list --query '[?isDefault].id' -o tsv)
$AZURE_TENANT_ID=(az account list --query '[?isDefault].tenantId' -o tsv) 
```
2. Crie uma entidade de serviço que tenha privilégios de Colaborador.
  
  Você pode criar uma entidade de serviço com a função de Colaborador ou usar uma função personalizada:
  - Função de Colaborador: a função de Colaborador concede acesso a toda a subscrição, por isso certifique-se de proteger esta credencial se atribuir essa função.
  - Função personalizada: se você precisar de uma função mais restritiva, use uma função personalizada.
  Atribua a função de Colaborador:
  
  Se você estiver usando o Velero para fazer backup de vários clusters com vários contêineres de blob, convém criar um nome de usuário exclusivo para cada cluster em vez de usar o nome velero.
  
  Para criar uma entidade de serviço com a função de Colaborador, use o comando a seguir. Substitua o seu próprio ID de subscrição e, opcionalmente, o seu próprio nome principal de serviço. Microsoft Entra ID irá gerar um segredo para você.
```
$AZURE_CLIENT_SECRET=(az ad sp create-for-rbac --name "velero" --role "Contributor" --query 'password' -o tsv --scopes  /subscriptions/$AZURE_SUBSCRIPTION_ID)
```
  Faça estes ajustes no comando, se necessário:
  - Se você planeja usar assinaturas diferentes para seu cluster de carga de trabalho e seus arquivos de backup do Velero, forneça ambas as IDs de assinatura, como no exemplo a seguir:
```
$AZURE_CLIENT_SECRET=(az ad sp create-for-rbac --name "velero" --role "Contributor" --query 'password' -o tsv --scopes  /subscriptions/$AZURE_SUBSCRIPTION_ID /subscriptions/$AZURE_BACKUP_SUBSCRIPTION_ID)
```
  - Se você não quiser usar velero como seu nome principal de serviço, verifique se a --name opção é exclusiva na ID do Microsoft Entra e não entra em conflito com outras entidades de serviço ou registros de aplicativos.
  Importante
  
  O segredo é mostrado somente durante esta etapa, quando a entidade de serviço é criada. Certifique-se de anotar o segredo para usar em etapas futuras.
  
  Use uma função personalizada:
  
  Se você quiser habilitar as ações mínimas do provedor de recursos, crie uma função personalizada e atribua essa função à entidade de serviço.
  1. Crie um arquivo chamado azure-role.json com o seguinte conteúdo. Substitua seu próprio nome de função personalizado e ID de assinatura.
```
{
    "Name": <CUSTOM_ROLE_NAME>,
    "Id": null,
    "IsCustom": true,
    "Description": "Velero related permissions to perform backups, restores and deletions",
    "Actions": [
        "Microsoft.Compute/disks/read",
        "Microsoft.Compute/disks/write",
        "Microsoft.Compute/disks/endGetAccess/action",
        "Microsoft.Compute/disks/beginGetAccess/action",
        "Microsoft.Compute/snapshots/read",
        "Microsoft.Compute/snapshots/write",
        "Microsoft.Compute/snapshots/delete",
        "Microsoft.Storage/storageAccounts/listkeys/action",
        "Microsoft.Storage/storageAccounts/regeneratekey/action"
    ],
    "NotActions": [],
    "AssignableScopes": [
      "<SUBSCRIPTION_ID>"
    ]
}
```
  2. Crie a função personalizada e a entidade de serviço:
```
az role definition create --role-definition azure-role.json

$AZURE_CLIENT_SECRET=(az ad sp create-for-rbac --name "velero" --role "<CUSTOM_ROLE>" --query 'password' -o tsv --scopes  /subscriptions/$AZURE_SUBSCRIPTION_ID)
```
  Para obter mais informações sobre como criar funções personalizadas, consulte Definir permissões para Velero.
Obtenha o nome da entidade de serviço e atribua esse nome à variável AZURE_CLIENT_ID :
```
$AZURE_CLIENT_ID=(az ad sp list --display-name "velero" --query '[0].appId' -o tsv)
```
Nota

As entidades de serviço expiram. Para saber quando a nova entidade de serviço expirará, execute este comando: az ad sp show --id $AZURE_CLIENT_ID.
Crie um arquivo que contenha as variáveis necessárias para a instalação do Velero. O comando é semelhante ao seguinte:
```
AZURE_SUBSCRIPTION_ID=${AZURE_SUBSCRIPTION_ID}
AZURE_TENANT_ID=${AZURE_TENANT_ID}
AZURE_CLIENT_ID=${AZURE_CLIENT_ID}
AZURE_CLIENT_SECRET=${AZURE_CLIENT_SECRET}
AZURE_RESOURCE_GROUP=${AZURE_BACKUP_RESOURCE_GROUP}
AZURE_CLOUD_NAME=AzurePublicCloud" | Out-File -FilePath ./credentials-velero.txt
```
Importante

Exclua este arquivo depois de instalar o Velero. O segredo do cliente está em texto simples, o que pode representar um risco de segurança.

Antes de continuar, verifique se o arquivo está formatado corretamente. A extensão de nome de arquivo não importa.
- Remova todos os espaços ou separadores adicionais.
- Verifique se os nomes das variáveis estão corretos.
Instale e inicie o Velero.

Instale o Velero no cluster e inicie a implantação. Este procedimento cria um namespace chamado velero e adiciona uma implantação nomeada velero ao namespace.
1. Instale o Velero usando o seguinte comando. Você precisará personalizar o comando de exemplo.
```
velero install --provider azure --plugins velero/velero-plugin-for-microsoft-azure:v1.5.0 --bucket $BLOB_CONTAINER --secret-file ./credentials-velero.txt --backup-location-config resourceGroup=$AZURE_BACKUP_RESOURCE_GROUP,storageAccount=$AZURE_STORAGE_ACCOUNT_ID,subscriptionId=$AZURE_BACKUP_SUBSCRIPTION_ID --use-restic
```
  Defina as seguintes variáveis conforme necessário:
  - O comando instala o plug-in do Microsoft Azure, que deve ser compatível com a versão da CLI do Velero que você está usando. O comando de exemplo usa o plug-in do Microsoft Azure versão 1.5.0, que é compatível com a versão mais recente da CLI do Velero, 1.9.0. Para descobrir qual versão do plug-in do Microsoft Azure instalar com sua versão da CLI do Valero, consulte a matriz de compatibilidade.
  - Certifique-se de incluir o parâmetro para habilitar o --use-restic backup de volumes do Kubernetes no nível do sistema de arquivos usando Restico . Restic pode ser usado para fazer backup de qualquer tipo de volume do Kubernetes. Por padrão, o Velero oferece suporte à captura de instantâneos de volumes persistentes para volumes do Amazon EBS, Azure Managed Disks e Google Persistent Disks. No AKS Arc, os volumes do Kubernetes usam Volumes Compartilhados de Cluster (CSVs) para armazenar dados. Portanto, Restic é necessário habilitar instantâneos de volume persistentes. Atualmente, o AKS Arc não suporta instantâneos de volume.
  - subscriptionId=$AZURE_BACKUP_SUBSCRIPTION_ID é opcional. Você só precisará incluí-lo se o Velero e o cluster de carga de trabalho tiverem IDs de assinatura diferentes. Se eles usarem a mesma assinatura do Azure, você poderá remover o subscriptionId parâmetro e o arquivo credentials-velero.txt fornecerá essas informações.
  O serviço Velero é iniciado automaticamente na instalação.
2. Verifique se o serviço Velero está funcionando corretamente:
```
kubectl -n velero get pods
kubectl logs deployment/velero -n velero
```
  O get pods comando deve mostrar que os pods Velero estão em execução.

Instale o Velero com armazenamento MinIO

Os procedimentos nesta seção descrevem como instalar o Velero e usar o armazenamento MinIO para backups. Se preferir usar o Armazenamento de Blobs do Azure para seus backups, vá para Instalar o Velero com o Armazenamento de Blobs do Azure.

Se você não quiser armazenar seus backups no MinIO, vá para Configurar o Velero para usar o Armazenamento de Blobs do Azure.

Instale a CLI do Velero executando o seguinte comando. Instale Chocolately se ainda não o fez.
```
choco install velero
```

Instale o MinIO:

Crie um volume persistente para armazenar o backup do MinIO. O exemplo cria um volume persistente na classe de armazenamento padrão no AKS Arc, que já existe.

Crie um arquivo YAML chamado minio-pvc-storage.yaml, com o seguinte conteúdo:

kind: PersistentVolumeClaim
apiVersion: v1
metadata: 
name: minio-pv-claim 
spec: 
storageClassName: default 
accessModes: 
   - ReadWriteOnce 
resources: 
   requests: 
      storage: 100Gi

Crie o volume persistente executando este comando:

kubectl create -f minio-pvc-storage.yaml

Crie um arquivo de implantação, minio-deployment.yaml, para iniciar o MinIO. Inclua o seguinte conteúdo. A implantação usará o volume persistente que você criou.

apiVersion: apps/v1
kind: Deployment
metadata:
name: minio-deployment 
spec: 
selector: 
   matchLabels: 
      app: minio 
strategy: 
   type: Recreate 
template: 
   metadata: 
      labels: 
      app: minio 
   spec: 
      volumes: 
      - name: storage 
      persistentVolumeClaim: 
         claimName: minio-pv-claim 
      containers: 
      - name: minio 
      image: minio/minio:latest 
      args:
      - server 
      - /storage 
      env: 
      - name: MINIO_ACCESS_KEY 
        value: "<you can define this>" 
      - name: MINIO_SECRET_KEY 
        value: "<you can define this>" 
      ports: 
      - containerPort: 9000 
        hostPort: 9000 
      volumeMounts: 
      - name: storage  
        mountPath: "/storage"

Em seguida, crie a implantação:

kubectl create -f minio-deployment.yaml

Crie um serviço Kubernetes chamado minio-service.yaml. Este serviço fornecerá endereços IP externos para o pod MinIO.

Crie um arquivo YAML com as seguintes configurações para configurar o serviço:
```
apiVersion: v1 
kind: Service 
metadata: 
name: minio-service 
spec: 
type: LoadBalancer 
ports: 
   - port: 9000 
     targetPort: 9000 
     protocol: TCP 
selector: 
   app: minio 
```
Em seguida, crie o serviço:
```
kubectl create -f mino-service.yaml
```
Obtenha o endereço IP externo do pod MinIO executando o seguinte comando. Você usará esse endereço para instalar o Velero.
```
kubectl get svc
```
Para verificar se o MinIO está em funcionamento, faça login no endereço IP em um navegador ou use o cliente MinIO, conforme descrito abaixo.

Instale o cliente MinIO e navegue pelos arquivos MinIO.

Faça o download do cliente MinIO:
```
Invoke-WebRequest -Uri "https://dl.minio.io/client/mc/release/windows-amd64/mc.exe" -OutFile "C:\mc.exe
```
Em seguida, defina um alias:
```
mc alias set minio http://10.10.77.6:9000 "minio_access_key" "minio_secret_key" --api s3v4
```
Finalmente, navegue pela instalação do MinIO:
```
mc ls minio
```
Crie um bucket para armazenar arquivos Velero. Este balde será usado na instalação do Velero.
```
mc mb minio/velero-backup
```

Crie um arquivo de credenciais MinIO minio.credentials com as seguintes informações:

[default] 
aws_access_key_id=<minio_access_key> 
aws_secret_access_key=<minio_secret_key>

Instale Velero:

velero install --provider aws --bucket velero-backup --secret-file .\minio.credentials --backup-location-config region=minio,s3ForcePathStyle=true,s3Url=http://10.10.77.6:9000 --plugins velero/velero-plugin-for-aws:v1.1.0 --use-restic

Antes de executar esse comando, verifique o nome do bucket, suas credenciais MinIO e o endereço IP externo MinIO.

Verifique se o serviço Velero está funcionando corretamente:
```
kubectl -n velero get pods
kubectl logs deployment/velero -n Velero
```
O get pods comando deve mostrar que os pods Velero estão em execução.

Fazer backup de um cluster

Você pode fazer backup ou restaurar todos os objetos em seu cluster ou pode filtrar objetos por tipo, namespace e/ou rótulo.

Criar uma cópia de segurança

Use o comando Velero backup create para criar backups para o armazenamento escolhido. Os exemplos a seguir usam o --default-volumes-to-restic sinalizador, que cria um instantâneo dos volumes persistentes. Para outras opções de backup, consulte a Referência do Velero Backup.

Backup sob demanda de todos os namespaces em seu cluster:

velero backup create <BACKUP-NAME> --default-volumes-to-restic

Backup sob demanda de um único namespace em seu cluster:

velero backup create <BACKUP-NAME> --include-namespaces <NAMESPACE1> --default-volumes-to-restic

Backup sob demanda de vários namespaces selecionados em seu cluster:

velero backup create <BACKUP-NAME> --include-namespaces <NAMESPACE-1>, <NAMESPACE-2> --default-volumes-to-restic

Verificar o progresso do backup

Para verificar o progresso de um backup, execute este comando:
```
velero backup describe <BACKUP-NAME>
```
Se você estiver usando o Armazenamento de Blob do Azure para seus backups, poderá exibir seu backup em sua conta de armazenamento do Azure sob o blob/contêiner que você criou.

Restaurar um cluster

Para restaurar um cluster, você deve criar um novo cluster para restaurar o cluster antigo. Não é possível restaurar um backup de cluster para um cluster existente.

O restore comando permite restaurar todos os objetos e volumes persistentes de um backup criado anteriormente. Também é possível restaurar apenas um subconjunto filtrado de objetos e volumes persistentes. Para obter mais opções de backup, consulte Filtragem de recursos.

No cluster para o qual você deseja restaurar o backup (o cluster de destino):

Implante o Velero usando as instruções acima. Use as mesmas credenciais do Azure que você usou para o cluster de origem.
Verifique se o objeto de backup do Velero foi criado executando o seguinte comando. Os recursos do Velero são sincronizados com os arquivos de backup no armazenamento em nuvem.
```
velero backup describe <BACKUP-NAME>
```
Depois de confirmar que o backup correto (BACKUP-NAME) está presente, restaure todos os objetos no backup:
```
velero restore create --from-backup <BACKUP-NAME>
```

Obter ajuda com os comandos do Velero

Para ver todas as opções associadas a um comando Velero específico, use o --help sinalizador com o comando. Por exemplo, velero restore create --help mostra todas as opções associadas ao velero restore create comando.

Por exemplo, para listar todas as opções do velero restore, execute velero restore --help, que retorna as seguintes informações:

  velero restore [command]
  Available Commands:
  create      Create a restore
  delete      Delete restores
  describe    Describe restores
  get         Get restores
  logs        Get restore logs

Desinstalar Velero

Para desinstalar o Velero do cluster e remover todos os recursos criados pela instalação do Velero, execute os seguintes comandos:

kubectl delete namespace/velero clusterrolebinding/velero 
kubectl delete crds -l component=velero

Partilhar via