Fazer backup, restaurar clusters de carga de trabalho usando o Velero

Artigo
04/27/2023

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 Armazenamento de Blobs do Azure ou armazenamento MinIO no AKS habilitado pelo Azure Arc.

O Velero é uma ferramenta padrão da comunidade de software livre para fazer backup e restaurar objetos de cluster do Kubernetes e volumes persistentes. Ele dá suporte a vários provedores de armazenamento para armazenar seus backups. Se um cluster kubernetes de destino do 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 Armazenamento de Blobs do Azure ou instalar e configurar o Velero para usar o armazenamento MinIO.

Observação

O Velero não dá suporte oficialmente ao Microsoft Windows. Em testes, a equipe do Velero conseguiu fazer backup apenas de aplicativos do Windows sem estado. Restic não há suporte para integração e backups de aplicativos com estado ou volumes persistentes.

Pré-requisitos

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

Instale a CLI do Azure.
Instale Chocolateyo . Você pode usar Chocolatey para instalar o cliente Velero, que inclui a CLI do Velero, em um computador Windows.

Instalar o Velero com Armazenamento de Blobs do Azure

Os procedimentos nesta seção descrevem como instalar o Velero e usar Armazenamento de Blobs do Azure para backups. Se você não quiser armazenar seus backups no Azure, acesse 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 tem mais suporte 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 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.

Alterne 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 blobs.

Quando você usa 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 pode 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 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 preferencial, 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. Criar 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, preferencialmente exclusivo para um único cluster do Kubernetes.
Criar 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 colaborador: A função Colaborador concede acesso em toda a assinatura, portanto, proteja 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 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 de entidade de serviç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 seus 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 o nome da entidade de serviço, verifique se a --name opção escolhida é exclusiva no Microsoft Entra ID e não está 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. Anote 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 conteúdo a seguir. Substitua seu próprio nome de função personalizada e ID da 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 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 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 esse arquivo depois de instalar o Velero. O segredo do cliente está em texto não criptografado, o que pode representar um risco à segurança.

Antes de continuar, verifique se o arquivo está formatado corretamente. A extensão de nome de arquivo não importa.
- Remova 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. Esse procedimento cria um namespace chamado velero e adiciona uma implantação chamada velero ao namespace .
1. Instale o Velero usando o comando a seguir. 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, confira a matriz de compatibilidade.
  - Inclua o parâmetro para habilitar o --use-restic backup de volumes do Kubernetes no nível do sistema de arquivos usando Restic. Restic pode ser usado para fazer backup de qualquer tipo de volume do Kubernetes. Por padrão, o Velero dá suporte à captura de instantâneos de volumes persistentes para Amazon EBS Volumes, Azure Managed Disks e Google Persistent Disks. No AKS Arc, os volumes do Kubernetes usam CSVs (Volumes Compartilhados Clusterizados) para armazenar dados. Portanto, Restic é necessário habilitar instantâneos de volume persistentes. No momento, 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á sendo executado 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.

Instalar o Velero com o armazenamento MinIO

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

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

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

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

Em seguida, 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 definir 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 marcar se o MinIO está em execução, faça logon 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 Velero. Esse bucket será usado na instalação do Velero.
```
mc mb minio/velero-backup
```

Crie um arquivo de credenciais do MinIO com as seguintes informações:

minio.credentials 
       [default] 
  aws_access_key_id=<minio_access_key> 
  aws_secret_access_key=<minio_secret_key>

Instalar 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, marcar o nome do bucket, suas credenciais do MinIO e o endereço IP externo do MinIO.

Verifique se o serviço Velero está sendo executado 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 backup create para criar backups no armazenamento escolhido. Os exemplos a seguir usam o --default-volumes-to-restic sinalizador , que cria uma 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 no 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 no cluster:

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

Verificar o progresso do backup

Para marcar progresso de um backup, execute este comando:
```
velero backup describe <BACKUP-NAME>
```
Se você estiver usando 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 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 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 comandos 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 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