Eseguire il backup, ripristinare i cluster del carico di lavoro usando Velero

Articolo
07/03/2024

Si applica a: Servizio Azure Kubernetes in Azure Stack HCI 22H2, servizio Azure Kubernetes in Windows Server

Questo articolo descrive come installare e usare Velero per eseguire il backup e il ripristino di cluster di carico di lavoro e di destinazione usando Archiviazione BLOB di Azure o l'archiviazione MinIO nel servizio Azure Kubernetes abilitato da Azure Arc.

Velero è uno strumento standard della community open source per il backup e il ripristino di oggetti cluster Kubernetes e volumi permanenti. Supporta vari provider di archiviazione per archiviare i backup. Se un cluster Kubernetes di destinazione del servizio Azure Kubernetes si arresta in modo anomalo e non riesce a eseguire il ripristino, è possibile usare un backup di Velero per ripristinare il contenuto e gli oggetti API interni in un nuovo cluster.

Se non si desidera archiviare i backup in Archiviazione BLOB di Azure, è possibile usare MinIO con Velero. Questo articolo descrive come installare e configurare Velero per usare Archiviazione BLOB di Azure o installare e configurare Velero per l'uso dello spazio di archiviazione MinIO.

Nota

Velero non supporta ufficialmente Microsoft Windows. Nel test, il team di Velero è riuscito a eseguire il backup solo di applicazioni Windows senza stato. Restic l'integrazione e i backup di applicazioni con stato o volumi permanenti non sono supportati.

Prerequisiti

Completare questi prerequisiti prima di iniziare la distribuzione di Velero:

Installare l'interfaccia della riga di comando di Azure
Installare Chocolatey. È possibile usare Chocolatey per installare il client Velero, che include l'interfaccia della riga di comando di Velero, in un computer Windows.

Installare Velero con Archiviazione BLOB di Azure

Le procedure descritte in questa sezione descrivono come installare Velero e usare Archiviazione BLOB di Azure per i backup. Se non si vogliono archiviare i backup in Azure, passare a Installare Velero con l'archiviazione MiniO.

Aprire PowerShell come amministratore.
Accedere ad Azure usando l'interfaccia della riga di comando di Azure:
```
az login --use-device-code   
```
Installare l'interfaccia della riga di comando di Velero eseguendo il comando seguente:

Nota

Il --use-restic flag non è supportato in Velero versione 1.10 e successive. Il flag è supportato solo nella versione 1.9.x.
```
choco install velero   
```
Se necessario, passare alla sottoscrizione di Azure che si vuole usare per i backup.

Per impostazione predefinita, Velero archivia i backup nella stessa sottoscrizione di Azure delle macchine virtuali e dei dischi e non consente di ripristinare i backup in un gruppo di risorse in una sottoscrizione diversa. Per abilitare le operazioni di backup e ripristino tra sottoscrizioni, specificare una sottoscrizione da usare per i backup. È possibile ignorare questo passaggio se si è già nella sottoscrizione che si vuole usare per i backup.

Passare alla sottoscrizione che si vuole usare per i backup:
1. Usare il nome della sottoscrizione per trovare l'ID sottoscrizione:
```
$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. Modificare quindi la sottoscrizione:
```
az account set -s $AZURE_BACKUP_SUBSCRIPTION_ID
```
Creare un account di archiviazione di Azure e un contenitore BLOB.

Quando si usa Archiviazione BLOB di Azure per i backup, Velero richiede un account di archiviazione e un contenitore BLOB per archiviare i backup. L'esempio seguente illustra l'account di archiviazione creato in un nuovo gruppo di risorse Velero_Backups .

È necessario creare l'account di archiviazione con un ID univoco globale che può essere usato in DNS. Lo script di esempio usa l'app uuidgen per generare in modo casuale un nome univoco. È possibile usare qualsiasi metodo purché il nome segua le regole di denominazione di Azure per gli account di archiviazione.

L'account di archiviazione viene creato con le funzionalità di crittografia dei dati inattivi (usando chiavi gestite da Microsoft) ed è configurato per consentire l'accesso solo tramite connessioni HTTPS.

Per creare l'account di archiviazione e il contenitore BLOB, seguire questa procedura:
1. Creare un gruppo di risorse per l'account di archiviazione di backup. Modificare le directory nel percorso preferito, se necessario ed eseguire i comandi seguenti:
```
$AZURE_BACKUP_RESOURCE_GROUP="Velero_Backups"
az group create -n $AZURE_BACKUP_RESOURCE_GROUP --location WestUS
```
2. Creare l'account di archiviazione:
```
$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. Creare un contenitore BLOB:
```
$BLOB_CONTAINER="velero"
az storage container create -n $BLOB_CONTAINER --public-access off --account-name $AZURE_STORAGE_ACCOUNT_ID
```
  Nell'esempio viene usato un contenitore BLOB denominato velero. È possibile usare un nome diverso, preferibilmente univoco per un singolo cluster Kubernetes.
Creare un'entità servizio:
1. Ottenere l'ID sottoscrizione e l'ID tenant per l'account Azure:
```
$AZURE_SUBSCRIPTION_ID=(az account list --query '[?isDefault].id' -o tsv)
$AZURE_TENANT_ID=(az account list --query '[?isDefault].tenantId' -o tsv) 
```
2. Creare un'entità servizio con privilegi di Collaboratore.
  
  È possibile creare un'entità servizio con il ruolo Collaboratore o usare un ruolo personalizzato:
  - Ruolo Collaboratore: il ruolo Collaboratore concede l'accesso a livello di sottoscrizione, quindi assicurarsi di proteggere queste credenziali se si assegna tale ruolo.
  - Ruolo personalizzato: se è necessario un ruolo più restrittivo, usare un ruolo personalizzato.
  Assegnare il ruolo Collaboratore:
  
  Se si usa Velero per eseguire il backup di più cluster con più contenitori BLOB, è possibile creare un nome utente univoco per ogni cluster anziché usare il nome velero.
  
  Per creare un'entità servizio con il ruolo Collaboratore, usare il comando seguente. Sostituire il proprio ID sottoscrizione e, facoltativamente, il nome dell'entità servizio. Microsoft Entra ID genererà automaticamente un segreto.
```
$AZURE_CLIENT_SECRET=(az ad sp create-for-rbac --name "velero" --role "Contributor" --query 'password' -o tsv --scopes  /subscriptions/$AZURE_SUBSCRIPTION_ID)
```
  Apportare queste modifiche al comando, se necessario:
  - Se si prevede di usare sottoscrizioni diverse per il cluster del carico di lavoro e i file di backup di Velero, specificare entrambi gli ID sottoscrizione, come nell'esempio seguente:
```
$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 non si vuole usare velero come nome dell'entità servizio, assicurarsi che sia --name univoco in Microsoft Entra ID e che non sia in conflitto con altre entità servizio o registrazioni dell'app.
  Importante
  
  Il segreto viene visualizzato solo durante questo passaggio, quando viene creata l'entità servizio. Assicurarsi di prendere nota del segreto da usare nei passaggi futuri.
  
  Usare un ruolo personalizzato:
  
  Se si desidera abilitare le azioni minime del provider di risorse, creare un ruolo personalizzato e assegnare tale ruolo all'entità servizio.
  1. Creare un file denominato azure-role.json con il contenuto seguente. Sostituire il nome del ruolo personalizzato e l'ID sottoscrizione:
```
{
    "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. Creare il ruolo personalizzato e l'entità servizio:
```
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)
```
  Per altre informazioni sulla creazione di ruoli personalizzati, vedere Impostare le autorizzazioni per Velero.
Ottenere il nome dell'entità servizio e assegnarlo alla variabile AZURE_CLIENT_ID :
```
$AZURE_CLIENT_ID=(az ad sp list --display-name "velero" --query '[0].appId' -o tsv)
```
Nota

Le entità servizio scadono. Per scoprire quando scade la nuova entità servizio, eseguire questo comando: az ad sp show --id $AZURE_CLIENT_ID.
Creare un file contenente le variabili richieste dall'installazione di Velero. Il comando è simile al seguente:
```
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

Eliminare questo file dopo aver installato Velero. Il segreto client è in testo non crittografato, che può rappresentare un rischio per la sicurezza.

Prima di procedere, verificare che il file sia formattato correttamente. L'estensione del nome file non è importante.
- Rimuovere eventuali spazi o schede aggiuntivi.
- Assicurarsi che i nomi delle variabili siano corretti.
Installare e avviare Velero.

Installare Velero nel cluster e avviare la distribuzione. Questa procedura crea uno spazio dei nomi denominato velero e aggiunge una distribuzione denominata velero allo spazio dei nomi .
1. Installare Velero usando il comando seguente. È necessario personalizzare il comando di esempio.
```
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
```
  Impostare le variabili seguenti in base alle esigenze:
  - Il comando installa il plug-in di Microsoft Azure, che deve essere compatibile con la versione dell'interfaccia della riga di comando di Velero in uso. Il comando di esempio usa il plug-in di Microsoft Azure versione 1.5.0, compatibile con la versione più recente dell'interfaccia della riga di comando di Velero, 1.9.0. Per scoprire quale versione del plug-in di Microsoft Azure installare con la versione dell'interfaccia della riga di comando di Valero, vedere la matrice di compatibilità.
  - Assicurarsi di includere il parametro per abilitare il --use-restic backup dei volumi Kubernetes a livello di file system usando Restic. Restic può essere usato per eseguire il backup di qualsiasi tipo di volume Kubernetes. Per impostazione predefinita, Velero supporta l'acquisizione di snapshot di volumi persistenti per i volumi Amazon EBS, Azure Managed Disks e Google Persistent Disks. In AKS Arc i volumi Kubernetes usano volumi condivisi cluster per archiviare i dati. Di conseguenza, Restic è necessario per abilitare gli snapshot del volume persistente. Azure Kubernetes Arc attualmente non supporta gli snapshot del volume.
  - subscriptionId=$AZURE_BACKUP_SUBSCRIPTION_ID è facoltativo. È necessario includerlo solo se Velero e il cluster del carico di lavoro hanno ID sottoscrizione diversi. Se usano la stessa sottoscrizione di Azure, è possibile rimuovere il subscriptionId parametro e il file di credentials-velero.txt fornirà tali informazioni.
  Il servizio Velero viene avviato automaticamente all'installazione.
2. Controllare se il servizio Velero è in esecuzione correttamente:
```
kubectl -n velero get pods
kubectl logs deployment/velero -n velero
```
  Il get pods comando dovrebbe indicare che i pod Velero sono in esecuzione.

Installare Velero con l'archiviazione MinIO

Le procedure descritte in questa sezione descrivono come installare Velero e usare l'archiviazione MinIO per i backup. Se si preferisce usare Archiviazione BLOB di Azure per i backup, passare a Installa Velero con Archiviazione BLOB di Azure.

Se non si vuole archiviare i backup in MinIO, passare a Configurare Velero per usare Archiviazione BLOB di Azure.

Installare l'interfaccia della riga di comando di Velero eseguendo il comando seguente. Installare Chocolately se non è già stato fatto.
```
choco install velero
```

Installare MinIO:

Creare un volume permanente per archiviare il backup MinIO. L'esempio crea un volume permanente nella classe di archiviazione predefinita in AKS Arc, già esistente.

Creare un file YAML denominato minio-pvc-storage.yaml con il contenuto seguente:

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

Creare il volume permanente eseguendo questo comando:

kubectl create -f minio-pvc-storage.yaml

Creare un file di distribuzione, minio-deployment.yaml, per l'avvio di MinIO. Includere il contenuto seguente. La distribuzione userà il volume permanente creato.

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"

Quindi, creare la distribuzione:

kubectl create -f minio-deployment.yaml

Creare un servizio Kubernetes denominato minio-service.yaml. Questo servizio fornirà indirizzi IP esterni al pod MinIO.

Creare un file YAML con le impostazioni seguenti per configurare il servizio:

apiVersion: v1 
kind: Service 
metadata: 
name: minio-service 
spec: 
type: LoadBalancer 
ports: 
   - port: 9000 
     targetPort: 9000 
     protocol: TCP 
selector: 
   app: minio

Creare quindi il servizio:

kubectl create -f mino-service.yaml

Ottenere l'indirizzo IP esterno del pod MinIO eseguendo il comando seguente. Si userà tale indirizzo per installare Velero.
```
kubectl get svc
```
Per verificare se MinIO è operativo, accedere all'indirizzo IP in un browser o usare il client MinIO, come descritto di seguito.

Installare il client MinIO ed esaminare i file MinIO.

Scaricare il client MinIO:
```
Invoke-WebRequest -Uri "https://dl.minio.io/client/mc/release/windows-amd64/mc.exe" -OutFile "C:\mc.exe
```
Impostare quindi un alias:
```
mc alias set minio http://10.10.77.6:9000 "minio_access_key" "minio_secret_key" --api s3v4
```
Infine, esaminare l'installazione di MinIO:
```
mc ls minio
```
Creare un bucket per archiviare i file Velero. Questo bucket verrà usato nell'installazione di Velero.
```
mc mb minio/velero-backup
```

Creare un file di credenziali MinIO minio.credentials con le informazioni seguenti:

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

Installare 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

Prima di eseguire questo comando, controllare il nome del bucket, le credenziali MinIO e l'indirizzo IP esterno MinIO.

Controllare se il servizio Velero è in esecuzione correttamente:
```
kubectl -n velero get pods
kubectl logs deployment/velero -n Velero
```
Il get pods comando dovrebbe indicare che i pod Velero sono in esecuzione.

Eseguire il backup di un cluster

È possibile eseguire il backup o il ripristino di tutti gli oggetti nel cluster oppure filtrare gli oggetti in base al tipo, allo spazio dei nomi e/o all'etichetta.

Creare un backup

Usare il comando Velero backup create per creare backup nello spazio di archiviazione scelto. Negli esempi seguenti viene usato il --default-volumes-to-restic flag , che crea uno snapshot dei volumi persistenti. Per altre opzioni di backup, vedere Le informazioni di riferimento sul backup di Velero.

Backup su richiesta di tutti gli spazi dei nomi nel cluster:

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

Backup su richiesta di un singolo spazio dei nomi nel cluster:

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

Backup su richiesta di più spazi dei nomi selezionati nel cluster:

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

Controllare lo stato di avanzamento del backup

Per controllare lo stato di avanzamento di un backup, eseguire questo comando:
```
velero backup describe <BACKUP-NAME>
```
Se si usa Archiviazione BLOB di Azure per i backup, è possibile visualizzare il backup nell'account di archiviazione di Azure nel BLOB/contenitore creato.

Ripristinare un cluster

Per ripristinare un cluster, è necessario creare un nuovo cluster per ripristinare il cluster precedente. Non è possibile ripristinare un backup del cluster in un cluster esistente.

Il restore comando consente di ripristinare tutti gli oggetti e i volumi permanenti da un backup creato in precedenza. È anche possibile ripristinare solo un subset filtrato di oggetti e volumi permanenti. Per altre opzioni di backup, vedere Filtro delle risorse.

Nel cluster in cui si vuole ripristinare il backup (cluster di destinazione):

Distribuire Velero usando le istruzioni riportate sopra. Usare le stesse credenziali di Azure usate per il cluster di origine.
Assicurarsi che l'oggetto di backup Velero sia stato creato eseguendo il comando seguente. Le risorse Velero vengono sincronizzate con i file di backup nell'archiviazione cloud.
```
velero backup describe <BACKUP-NAME>
```
Dopo aver verificato che il backup corretto (BACKUP-NAME) sia presente, ripristinare tutti gli oggetti nel backup:
```
velero restore create --from-backup <BACKUP-NAME>
```

Ottenere assistenza con i comandi di Velero

Per visualizzare tutte le opzioni associate a un comando Specifico di Velero, usare il --help flag con il comando . Ad esempio, velero restore create --help mostra tutte le opzioni associate al velero restore create comando .

Ad esempio, per elencare tutte le opzioni di velero restore, eseguire velero restore --help, che restituisce le informazioni seguenti:

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

Disinstallare Velero

Per disinstallare Velero dal cluster e rimuovere tutte le risorse create dall'installazione di Velero, eseguire i comandi seguenti:

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

Condividi tramite