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

2025-05-01

Si applica a: AKS su Windows Server

Questo articolo descrive come installare e usare Velero per eseguire il backup e il ripristino di carichi di lavoro e cluster di destinazione usando Azure Blob Storage o l'archiviazione MinIO nel cluster Azure Kubernetes su Windows Server.

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 AKS Arc si arresta in modo anomalo e non riesce a riprendersi, è possibile usare un backup di Velero per ripristinare il suo 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 l'Archiviazione BLOB di Azure o installare e configurare Velero per usare l'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

Prima di iniziare, verificare di aver soddisfatto i prerequisiti seguenti:

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, vedere 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 il Velero CLI 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. Crea 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à principale del 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 principale del servizio con i privilegi di Collaboratore.
  
  È possibile creare un principale del servizio con il ruolo Collaboratore oppure utilizzare 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 di 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 principale del servizio con il ruolo di Collaboratore, eseguire il seguente comando. Sostituire il proprio ID della sottoscrizione e, facoltativamente, il nome principale del servizio. Microsoft Entra ID genera 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 prevedi di usare abbonamenti diversi per il cluster del carico di lavoro e i file di backup di Velero, specificare entrambi gli ID abbonamento, 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 desidera usare velero come nome dell'entità servizio, assicurarsi che il valore --name scelto sia univoco in Microsoft Entra ID e che non confligga con altri nomi entità servizio o registrazioni delle app.
  Importante
  
  Il segreto viene visualizzato solo durante questo passaggio, quando viene creato il principale del servizio. Assicurarsi di prendere nota del segreto da usare nei passaggi futuri.
  
  Se si desidera abilitare le azioni minime necessarie del provider di risorse, creare un ruolo personalizzato e assegnare tale ruolo al principale del servizio.
3. 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>"
    ]
}
```
4. Creare il ruolo personalizzato e il principale del 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.
Ottieni il nome dell'entità servizio e assegna questo nome alla variabile AZURE_CLIENT_ID.
```
$AZURE_CLIENT_ID=(az ad sp list --display-name "velero" --query '[0].appId' -o tsv)
```
Nota

I principali del servizio scadono. Per scoprire quando scade il nuovo principale del 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 normale, 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 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. Assicurarsi di sostituire i segnaposto nel comando di esempio con i propri valori:
```
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 --use-restic per abilitare il 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, è necessario Restic per abilitare gli snapshot persistenti del volume. AKS Arc attualmente non supporta gli snapshot dei volumi.
  - subscriptionId=$AZURE_BACKUP_SUBSCRIPTION_ID è facoltativo. È necessario includerlo solo se Velero e il cluster di lavoro hanno ID sottoscrizione diversi. Se usano la stessa sottoscrizione di Azure, è possibile rimuovere il subscriptionId parametro e il file dicredentials-velero.txt fornisce 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"

Creare quindi 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. Usare 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 in questa sezione. 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 il contenuto seguente:

[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 on-demand di tutti i namespace nel cluster.

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

Backup on-demand di un singolo namespace nel tuo cluster.

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

Backup su richiesta di più namespace 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 usi Azure Blob Storage per i backup, puoi visualizzare i tuoi backup nell'account Azure sotto il blob/contenitore che hai 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 (il 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