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

Artigo
11/23/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.

O 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 oferece suporte a vários provedores de armazenamento para armazenar seus backups. Se um cluster do Kubernetes de destino do AKS Arc falhar e não se recuperar, você poderá usar um backup do Velero para restaurar seu conteúdo e objetos de API internos para um novo cluster.

Se você não quiser armazenar seus backups no Armazenamento de Blobs do Azure, poderá usar o MinIO com o 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.

Observação

O Velero não oferece suporte oficial ao Microsoft Windows. Nos testes, a equipe do Velero conseguiu fazer backup apenas de aplicativos Windows sem estado. Restic A integração e os backups de aplicativos com estado ou volumes persistentes não eram suportados.

Pré-requisitos

Conclua estes pré-requisitos antes de iniciar a implantação do Velero:

Instale a CLI do Azure.
Instalar Chocolatey. 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 Blobs 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 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:

Observação

Não há suporte para o --use-restic sinalizador no Velero versão 1.10 e posterior. O sinalizador só tem suporte na versão 1.9.x.
```
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 permitirá que você restaure backups para um grupo de recursos em uma assinatura diferente. Para habilitar operações de backup e restauração entre assinaturas, especifique uma assinatura a ser usada para seus backups. Você pode pular esta etapa se já estiver na assinatura que deseja usar para seus backups.

Alterne para a assinatura que deseja usar para seus backups:
1. Use o nome da assinatura para localizar 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 Blobs 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 uma ID globalmente exclusiva que possa ser usada 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 apenas o acesso por meio de 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. Criar 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 do Kubernetes.
Crie uma entidade de serviço:
1. Obtenha a ID da assinatura e a ID do locatário para 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 Colaborador ou usar uma função personalizada:
  - Função de Colaborador: a função de Colaborador concede acesso em toda a assinatura, portanto, certifique-se de proteger essa credencial se você 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 Colaborador, use o comando a seguir. Substitua sua própria ID de assinatura e, opcionalmente, seu próprio nome da entidade de serviço. O Microsoft Entra ID 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 o cluster de carga de trabalho e os arquivos de backup do Velero, forneça as duas 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 nome da entidade de serviço, verifique se a --name escolha é exclusiva na ID do Microsoft Entra e não entra em conflito com outras entidades de serviço ou registros de aplicativo.
  Importante
  
  O segredo é mostrado somente durante esta etapa, quando a entidade de serviço é criada. Certifique-se de anotar o segredo para uso 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",
        "Microsoft.Storage/storageAccounts/read"
    ],
    "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 o 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)
```
Observação

As entidades de serviço expiram. Para descobrir quando sua nova entidade de serviço expira, execute este comando: az ad sp show --id $AZURE_CLIENT_ID.
Crie um arquivo que contenha as variáveis que a instalação do Velero requer. 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 do nome do arquivo não importa.
- Remova quaisquer espaços ou tabulações extras.
- Certifique-se de que os nomes das variáveis estejam 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 a snapshots de volumes persistentes para volumes do Amazon EBS, Azure Managed Disks e Google Persistent Disks. No AKS Arc, os volumes do Kubernetes usam CSVs (Volumes Compartilhados de Cluster) para armazenar dados. Portanto, Restic é necessário habilitar instantâneos de volume persistentes. Atualmente, o AKS Arc não dá suporte a 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 do 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 você preferir usar o Armazenamento de Blobs do Azure para seus backups, acesse Instalar o Velero com o Armazenamento de Blobs do Azure.

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

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

Instale o MinIO:

Crie um volume persistente para armazenar o backup 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"

Depois, crie a implantação:

kubectl create -f minio-deployment.yaml

Crie um serviço do Kubernetes chamado minio-service.yaml. Esse 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 comando a seguir. Você usará esse endereço para instalar o Velero.
```
kubectl get svc
```
Para verificar se o MinIO está funcionando, 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.

Baixe o 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
```
Por fim, navegue pela instalação do MinIO:
```
mc ls minio
```
Crie um bucket para armazenar arquivos do 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 o 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 do MinIO e o endereço IP externo do 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 do Velero estão em execução.

Fazer backup de um cluster

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

Criar um backup

Use o comando Velero backup create para criar backups no 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 de backup do Velero.

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

Verifique 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 Blobs do Azure para seus backups, poderá exibir seu backup em sua conta de armazenamento do Azure no 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. Você também pode 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.
Certifique-se de que o objeto de backup do Velero foi criado executando o comando a seguir. 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>
```

Obtenha ajuda com os comandos do Velero

Para ver todas as opções associadas a um comando específico do Velero, 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 de 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 o 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

Compartilhar via