Sauvegardez et restaurez des clusters de charge de travail à l'aide de Velero

2025-05-07

S’applique à : AKS sur Windows Server

Cet article explique comment installer et utiliser Velero pour sauvegarder et restaurer la charge de travail et les clusters cibles à l’aide du stockage Blob Azure ou du stockage MinIO dans AKS sur Windows Server.

Velero est un outil standard de la communauté open source pour sauvegarder et restaurer des objets de cluster Kubernetes et des volumes persistants. Il prend en charge différents fournisseurs de stockage pour stocker ses sauvegardes. Si un cluster Kubernetes cible AKS Arc se bloque et ne parvient pas à récupérer, vous pouvez utiliser une sauvegarde Velero pour restaurer son contenu et ses objets API internes sur un nouveau cluster.

Si vous ne souhaitez pas stocker vos sauvegardes dans Stockage Blob Azure, vous pouvez utiliser MinIO avec Velero. Cet article explique comment installer et configurer Velero pour utiliser le stockage Blob Azure ou installer et configurer Velero pour utiliser le stockage MinIO.

Remarque

Velero ne prend pas officiellement en charge Microsoft Windows. Lors des tests, l'équipe Velero a pu sauvegarder uniquement des applications Windows sans état. Restic L'intégration et les sauvegardes d'applications avec état ou de volumes persistants n'étaient pas prises en charge.

Prérequis

Avant de commencer, vérifiez que vous disposez des conditions préalables suivantes :

Installer l’interface de ligne de commande Microsoft Azure.
Installez Chocolatey. Vous pouvez utiliser Chocolatey pour installer le client Velero, qui inclut l’interface CLI Velero, sur un ordinateur Windows.

Installez Velero avec Azure Blob Storage

Les procédures de cette section décrivent comment installer Velero et utiliser Stockage Blob Azure pour les sauvegardes. Si vous ne souhaitez pas stocker vos sauvegardes dans Azure, consultez Installer Velero avec le stockage MiniO.

Ouvrez PowerShell en tant qu’administrateur.
Connectez-vous à Azure à l’aide d’Azure CLI :
```
az login --use-device-code   
```
Installez l’interface CLI Velero en exécutant la commande suivante :

Remarque

L’indicateur --use-restic n’est pas pris en charge sur Velero version 1.10 et ultérieure. L’indicateur est uniquement pris en charge sur la version 1.9.x.
```
choco install velero   
```
Si nécessaire, passez à l’abonnement Azure que vous souhaitez utiliser pour les sauvegardes.

Par défaut, Velero stocke les sauvegardes dans le même abonnement Azure que vos machines virtuelles et disques et ne vous permet pas de restaurer des sauvegardes dans un groupe de ressources dans un autre abonnement. Pour activer les opérations de sauvegarde et de restauration entre les abonnements, spécifiez un abonnement à utiliser pour vos sauvegardes. Vous pouvez ignorer cette étape si vous êtes déjà dans l’abonnement que vous souhaitez utiliser pour vos sauvegardes.

Basculez vers l’abonnement que vous souhaitez utiliser pour vos sauvegardes :
1. Utilisez le nom de l’abonnement pour rechercher l’ID d’abonnement :
```
$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. Ensuite, modifiez l’abonnement :
```
az account set -s $AZURE_BACKUP_SUBSCRIPTION_ID
```
Créez un compte de stockage Azure et un conteneur de blob.

Lorsque vous utilisez le stockage Azure Blob pour les sauvegardes, Velero nécessite un compte de stockage et un conteneur de blobs pour stocker les sauvegardes. L’exemple suivant montre le compte de stockage créé dans un nouveau groupe de ressources Velero_Backups .

Vous devez créer le compte de stockage avec un ID global unique qui peut être utilisé dans DNS. L’exemple de script utilise l’application uuidgen pour générer de façon aléatoire un nom unique. Vous pouvez utiliser n’importe quelle méthode tant que le nom suit les règles d’affectation de noms Azure pour les comptes de stockage.

Le compte de stockage est créé avec des fonctionnalités de chiffrement au repos (à l’aide de clés managées Microsoft) et est configuré pour autoriser uniquement l’accès via les connexions HTTPS.

Pour créer le compte de stockage et le conteneur blob, procédez comme suit :
1. Créez un groupe de ressources pour le compte de stockage de sauvegarde. Remplacez les répertoires par votre emplacement préféré, si nécessaire, puis exécutez les commandes suivantes :
```
$AZURE_BACKUP_RESOURCE_GROUP="Velero_Backups"
az group create -n $AZURE_BACKUP_RESOURCE_GROUP --location WestUS
```
2. Créez le compte de stockage :
```
$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. Créez un conteneur blob :
```
$BLOB_CONTAINER="velero"
az storage container create -n $BLOB_CONTAINER --public-access off --account-name $AZURE_STORAGE_ACCOUNT_ID
```
  L'exemple utilise un conteneur blob nommé velero. Vous pouvez utiliser un autre nom, de préférence unique pour un seul cluster Kubernetes.
Créez un principal de service :
1. Obtenez l’ID d’abonnement et l’ID de locataire pour votre compte Azure :
```
$AZURE_SUBSCRIPTION_ID=(az account list --query '[?isDefault].id' -o tsv)
$AZURE_TENANT_ID=(az account list --query '[?isDefault].tenantId' -o tsv) 
```
2. Créez un principal de service disposant de privilèges Contributeur.
  
  Vous pouvez créer un principal de service avec le rôle Contributeur ou utiliser un rôle personnalisé :
  - Rôle contributeur : le rôle Contributeur accorde un accès à l’échelle de l’abonnement. Veillez donc à protéger ces informations d’identification si vous attribuez ce rôle.
  - Rôle personnalisé : si vous avez besoin d’un rôle plus restrictif, utilisez un rôle personnalisé.
  Attribuer le rôle Contributeur :
  
  Si vous utilisez Velero pour sauvegarder plusieurs clusters avec plusieurs conteneurs d’objets blob, vous pouvez créer un nom d’utilisateur unique pour chaque cluster au lieu d’utiliser le nom velero.
  
  Pour créer un principal de service avec le rôle Contributeur, exécutez la commande suivante. Remplacez votre propre ID d’abonnement et éventuellement votre propre nom de principal de service. Microsoft Entra ID génère un secret pour vous :
```
$AZURE_CLIENT_SECRET=(az ad sp create-for-rbac --name "velero" --role "Contributor" --query 'password' -o tsv --scopes  /subscriptions/$AZURE_SUBSCRIPTION_ID)
```
  Effectuez ces ajustements sur la commande si nécessaire :
  - Si vous envisagez d’utiliser différents abonnements pour votre cluster de charge de travail et vos fichiers de sauvegarde Velero, fournissez les deux ID d’abonnement, comme dans l’exemple suivant :
```
$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)
```
  - Si vous ne souhaitez pas utiliser velero le nom de votre principal de service, vérifiez que la --name valeur que vous choisissez est unique dans l’ID Microsoft Entra et n’est pas en conflit avec d’autres principaux de service ou inscriptions d’applications.
  Importante
  
  Le secret est uniquement affiché au cours de cette étape, lorsque le principal de service est créé. Veillez à noter le secret à utiliser dans les prochaines étapes.
  
  Si vous souhaitez activer les actions minimales du fournisseur de ressources, créez un rôle personnalisé et attribuez ce rôle au principal de service.
3. Créez un fichier nommé azure-role.json avec le contenu suivant. Remplacez votre propre nom de rôle personnalisé et votre ID d’abonnement :
```
{
    "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. Créez le rôle personnalisé et le principal de service :
```
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)
```
Pour plus d’informations sur la création de rôles personnalisés, consultez Définir des autorisations pour Velero.
Obtenez le nom du principal de service et attribuez ce nom à la variable AZURE_CLIENT_ID :
```
$AZURE_CLIENT_ID=(az ad sp list --display-name "velero" --query '[0].appId' -o tsv)
```
Remarque

Les entités de service expirent. Pour savoir quand votre nouveau principal de service expire, exécutez cette commande : az ad sp show --id $AZURE_CLIENT_ID.
Créez un fichier qui contient les variables requises par l’installation de Velero. La commande ressemble à la commande suivante :
```
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

Supprimez ce fichier après avoir installé Velero. La clé secrète client est en texte brut, ce qui peut présenter un risque de sécurité.

Avant de continuer, vérifiez que le fichier est correctement mis en forme. L’extension de nom de fichier n’a pas d’importance.
- Supprimez les espaces ou onglets supplémentaires.
- Vérifiez que les noms des variables sont corrects.
Installez Velero sur le cluster et démarrez le déploiement. Cette procédure crée un espace de noms appelé velero et ajoute un déploiement nommé velero à l’espace de noms.
1. Installez Velero à l’aide de la commande suivante. Veillez à remplacer les espaces réservés dans l’exemple de commande par vos propres valeurs :
```
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
```
  Définissez les variables suivantes en fonction des besoins :
  - La commande installe le plug-in Microsoft Azure, qui doit être compatible avec la version de Velero CLI que vous utilisez. L’exemple de commande utilise le plug-in Microsoft Azure version 1.5.0, qui est compatible avec la dernière version de l’interface CLI Velero, 1.9.0. Pour savoir quelle version du plug-in Microsoft Azure installer avec votre version de Valero CLI, consultez la matrice de compatibilité.
  - Veillez à inclure le paramètre --use-restic pour activer la sauvegarde des volumes Kubernetes au niveau du système de fichiers en utilisant Restic. Restic peut être utilisé pour sauvegarder n’importe quel type de volume Kubernetes. Par défaut, Velero prend en charge la prise d’instantanés de volumes persistants pour les volumes Amazon EBS, Azure Disques managés et les disques persistants Google. Dans AKS Arc, les volumes Kubernetes utilisent des volumes partagés de cluster (CSV) pour stocker des données. Par conséquent, Restic est nécessaire pour activer les instantanés de volume persistant. AKS Arc ne prend actuellement pas en charge les instantanés de volume.
  - subscriptionId=$AZURE_BACKUP_SUBSCRIPTION_ID est facultatif. Vous devez uniquement l’inclure si Velero et le cluster de charge de travail ont des ID d’abonnement différents. S’ils utilisent le même abonnement Azure, vous pouvez supprimer le subscriptionId paramètre et le fichier credentials-velero.txt fournit ces informations.
  Le service Velero démarre automatiquement lors de l’installation.
2. Vérifiez si le service Velero s’exécute correctement :
```
kubectl -n velero get pods
kubectl logs deployment/velero -n velero
```
  La commande get pods devrait indiquer que les pods Velero sont en cours d'exécution.

Installer Velero avec le stockage MinIO

Les procédures de cette section décrivent comment installer Velero et utiliser le stockage MinIO pour les sauvegardes. Si vous préférez utiliser Stockage Blob Azure pour vos sauvegardes, accédez à Installer Velero avec Stockage Blob Azure.

Si vous ne souhaitez pas stocker vos sauvegardes dans MinIO, accédez à Configurer Velero pour utiliser Stockage Blob Azure.

Installez l’interface CLI Velero en exécutant la commande suivante. Installer Chocolately si vous ne l’avez pas déjà fait :
```
choco install velero
```

Installez MinIO :

Créez un volume persistant pour stocker la sauvegarde MinIO. L’exemple crée un volume persistant dans la classe de stockage par défaut dans AKS Arc, qui existe déjà.

Créez un fichier YAML nommé minio-pvc-storage.yaml, avec le contenu suivant :

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

Créez le volume persistant en exécutant cette commande :

kubectl create -f minio-pvc-storage.yaml

Créez un fichier de déploiement, minio-deployment.yaml, pour démarrer MinIO. Incluez le contenu suivant. Le déploiement utilise le volume persistant que vous avez créé.

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"

Ensuite, créez le déploiement :

kubectl create -f minio-deployment.yaml

Créez un service Kubernetes appelé minio-service.yaml. Ce service fournit des adresses IP externes au pod MinIO.

Créez un fichier YAML avec les paramètres suivants pour configurer le service :

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

Ensuite, créez le service :

kubectl create -f mino-service.yaml

Obtenez l’adresse IP externe du pod MinIO en exécutant la commande suivante. Vous utilisez cette adresse pour installer Velero :
```
kubectl get svc
```
Pour vérifier si MinIO est opérationnel, connectez-vous à l’adresse IP dans un navigateur ou utilisez le client MinIO, comme décrit dans cette section. Installez le client MinIO et parcourez les fichiers MinIO.

Téléchargez le client MinIO :
```
Invoke-WebRequest -Uri "https://dl.minio.io/client/mc/release/windows-amd64/mc.exe" -OutFile "C:\mc.exe
```
Ensuite, définissez un alias :
```
mc alias set minio http://10.10.77.6:9000 "minio_access_key" "minio_secret_key" --api s3v4
```
Enfin, parcourez l’installation de MinIO :
```
mc ls minio
```
Créez un compartiment pour stocker des fichiers Velero. Ce compartiment sera utilisé dans l’installation de Velero.
```
mc mb minio/velero-backup
```
Créez un fichier d’informations d’identification MinIO minio.credentials avec le contenu suivant :
```
[default] 
aws_access_key_id=<minio_access_key> 
aws_secret_access_key=<minio_secret_key> 
```

Installer 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

Avant d’exécuter cette commande, vérifiez le nom du compartiment, vos informations d’identification MinIO et l’adresse IP externe MinIO.

Vérifiez si le service Velero s’exécute correctement :
```
kubectl -n velero get pods
kubectl logs deployment/velero -n Velero
```
La commande get pods devrait indiquer que les pods Velero sont en cours d'exécution.

Sauvegarder un cluster

Vous pouvez sauvegarder ou restaurer tous les objets de votre cluster, ou filtrer des objets par type, espace de noms et/ou étiquette.

Création d'une sauvegarde

Utilisez la commande Velero backup create pour créer des sauvegardes dans votre stockage choisi. Les exemples suivants utilisent l’indicateur --default-volumes-to-restic , qui crée un instantané des volumes persistants. Pour obtenir d’autres options de sauvegarde, consultez la référence de sauvegarde Velero.

Sauvegarde à la demande de tous les espaces de noms de votre cluster :
```
velero backup create <BACKUP-NAME> --default-volumes-to-restic
```

Sauvegarde à la demande d’un espace de noms unique dans votre cluster :

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

Sauvegarde à la demande de plusieurs espaces de noms sélectionnés dans votre cluster :

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

Vérifier la progression de la sauvegarde

Pour vérifier la progression d’une sauvegarde, exécutez cette commande :
```
velero backup describe <BACKUP-NAME>
```
Si vous utilisez Stockage Blob Azure pour vos sauvegardes, vous pouvez afficher votre sauvegarde dans votre compte de stockage Azure sous l’objet blob/conteneur que vous avez créé.

Restaurer un cluster

Pour restaurer un cluster, vous devez créer un nouveau cluster sur lequel restaurer l'ancien cluster. Vous ne pouvez pas restaurer une sauvegarde de cluster sur un cluster existant.

La restore commande vous permet de restaurer tous les objets et volumes persistants à partir d’une sauvegarde créée précédemment. Vous pouvez aussi restaurer uniquement un sous-ensemble filtré d’objets et de volumes persistants. Pour plus d’options de sauvegarde, consultez Filtrage des ressources.

Sur le cluster sur lequel vous souhaitez restaurer la sauvegarde ( le cluster de destination) :

Déployez Velero à l’aide des instructions ci-dessus. Utilisez les mêmes informations d’identification Azure que celles que vous avez utilisées pour le cluster source.
Vérifiez que l’objet de sauvegarde Velero a été créé en exécutant la commande suivante. Les ressources Velero sont synchronisées avec les fichiers de sauvegarde dans le stockage cloud.
```
velero backup describe <BACKUP-NAME>
```
Une fois que vous avez confirmé que la sauvegarde appropriée (BACKUP-NAME) est présente, restaurez tous les objets de la sauvegarde :
```
velero restore create --from-backup <BACKUP-NAME>
```

Obtenir de l’aide sur les commandes Velero

Pour afficher toutes les options associées à une commande Velero spécifique, utilisez l’indicateur --help avec la commande. Par exemple, velero restore create --help montre toutes les options associées à la commande velero restore create.

Par exemple, pour répertorier toutes les options de velero restore, exécuter velero restore --help, qui retourne les informations suivantes :

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

Désinstaller Velero

Pour désinstaller Velero de votre cluster et supprimer toutes les ressources créées par l’installation de Velero, exécutez les commandes suivantes :

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