Faça backup, 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 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 falhar na recuperação, você poderá usar um backup 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

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

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

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 permitirá que você restaure backups em 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. Você pode ignorar esta etapa se já estiver na assinatura que deseja usar para seus backups.

Mude para a assinatura que você 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 da Microsoft) e é configurada para permitir acesso somente por conexões HTTPS.

Para criar a conta de armazenamento e o contêiner de blob, execute 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 de assinatura e a ID de 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 a 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 seu próprio ID de assinatura e, opcionalmente, seu próprio nome principal 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 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 de entidade de serviço, verifique se a --name opção escolhida é 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 essa 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 conteúdo a seguir. 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)
```
Observação

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 exigidas pela 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 sem formatação, o que pode representar um risco de segurança.

Antes de prosseguir, verifique se o arquivo está formatado corretamente. A extensão do nome do arquivo não importa.
- Remova quaisquer espaços ou guias extras.
- 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 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 snapshots de volumes persistentes para volumes do Amazon EBS, discos gerenciados do Azure e discos persistentes do Google. 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 oferece 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 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, 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 conteúdo a seguir. 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 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, efetue 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. Esta caçamba será utilizada 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 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 Velero estão em execução.

Fazer backup de um cluster

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

Criar um backup

Use o comando Velero para criar backups para o backup create armazenamento escolhido. Os exemplos a seguir usam o --default-volumes-to-restic sinalizador, que cria um instantâneo dos volumes persistentes. Para obter 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 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.
Verifique se o objeto de backup 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>
```

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