Sichern, Wiederherstellen von Workloadclustern mithilfe von Velero

Artikel
07/03/2024

Gilt für: AKS auf Azure Stack HCI 22H2, AKS unter Windows Server

In diesem Artikel wird beschrieben, wie Sie Velero installieren und verwenden, um Workload und Zielcluster mithilfe von Azure Blob Storage oder MinIO-Speicher in AKS zu sichern und wiederherzustellen, die von Azure Arc aktiviert sind.

Velero ist ein Open-Source-Communitystandardtool zum Sichern und Wiederherstellen von Kubernetes-Clusterobjekten und persistenten Volumes. Es unterstützt verschiedene Speicheranbieter , um ihre Sicherungen zu speichern. Wenn ein AKS Arc-Ziel-Kubernetes-Cluster abstürzt und nicht wiederhergestellt werden kann, können Sie eine Velero-Sicherung verwenden, um ihre Inhalte und internen API-Objekte in einem neuen Cluster wiederherzustellen.

Wenn Sie Ihre Sicherungen nicht in Azure Blob Storage speichern möchten, können Sie MinIO mit Velero verwenden. In diesem Artikel wird beschrieben, wie Sie Velero installieren und konfigurieren, um Azure Blob Storage zu verwenden oder Velero für die Verwendung von MinIO-Speicher zu installieren und zu konfigurieren.

Hinweis

Velero unterstützt Microsoft Windows nicht offiziell. Im Test konnte das Velero-Team nur zustandslose Windows-Anwendungen sichern. Restic Integration und Sicherungen zustandsbehafteter Anwendungen oder persistenter Volumes wurden nicht unterstützt.

Voraussetzungen

Führen Sie die folgenden Voraussetzungen aus, bevor Sie mit der Velero-Bereitstellung beginnen:

Installieren Sie die Azure-Befehlszeilenschnittstelle.
Installieren Sie Chocolatey. Sie können den Chocolatey Velero-Client installieren, der die Velero CLI enthält, auf einem Windows-Computer.

Installieren von Velero mit Azure Blob Storage

Die Verfahren in diesem Abschnitt beschreiben, wie Velero installiert und Azure Blob Storage für Sicherungen verwendet wird. Wenn Sie Ihre Sicherungen nicht in Azure speichern möchten, wechseln Sie zu "Velero mit MiniO-Speicher installieren".

Öffnen Sie PowerShell als Administrator.
Melden Sie sich mit der Azure CLI bei Azure an:
```
az login --use-device-code   
```
Installieren Sie die Velero CLI , indem Sie den folgenden Befehl ausführen:

Hinweis

Die --use-restic Kennzeichnung wird unter Velero, Version 1.10 und höher, nicht unterstützt. Das Flag wird nur unter Version 1.9.x unterstützt.
```
choco install velero   
```
Ändern Sie bei Bedarf das Azure-Abonnement, das Sie für die Sicherungen verwenden möchten.

Standardmäßig speichert Velero Sicherungen im selben Azure-Abonnement wie Ihre VMs und Datenträger und ermöglicht es Ihnen nicht, Sicherungen in einer Ressourcengruppe in einem anderen Abonnement wiederherzustellen. Um Sicherungs- und Wiederherstellungsvorgänge für Abonnements zu aktivieren, geben Sie ein Abonnement an, das für Ihre Sicherungen verwendet werden soll. Sie können diesen Schritt überspringen, wenn Sie sich bereits im Abonnement befinden, das Sie für Ihre Sicherungen verwenden möchten.

Wechseln Sie zu dem Abonnement, das Sie für Ihre Sicherungen verwenden möchten:
1. Verwenden Sie den Abonnementnamen, um die Abonnement-ID zu finden:
```
$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. Ändern Sie dann das Abonnement:
```
az account set -s $AZURE_BACKUP_SUBSCRIPTION_ID
```
Erstellen Sie ein Azure-Speicherkonto und einen BLOB-Container.

Wenn Sie Azure Blob Storage für Sicherungen verwenden, erfordert Velero ein Speicherkonto und einen BLOB-Container, um die Sicherungen zu speichern. Das folgende Beispiel zeigt das Speicherkonto, das in einer neuen Velero_Backups Ressourcengruppe erstellt wurde.

Sie müssen das Speicherkonto mit einer global eindeutigen ID erstellen, die in DNS verwendet werden kann. Das Beispielskript verwendet die uuidgen App, um zufällig einen eindeutigen Namen zu generieren. Sie können eine beliebige Methode verwenden, solange der Name Azure-Benennungsregeln für Speicherkonten folgt.

Das Speicherkonto wird mit ruhenden Verschlüsselungsfunktionen (mit von Microsoft verwalteten Schlüsseln) erstellt und so konfiguriert, dass nur der Zugriff über HTTPS-Verbindungen zulässig ist.

Führen Sie die folgenden Schritte aus, um das Speicherkonto und den BLOB-Container zu erstellen:
1. Erstellen Sie eine Ressourcengruppe für das Sicherungsspeicherkonto. Ändern Sie Verzeichnisse bei Bedarf in Ihren bevorzugten Speicherort, und führen Sie die folgenden Befehle aus:
```
$AZURE_BACKUP_RESOURCE_GROUP="Velero_Backups"
az group create -n $AZURE_BACKUP_RESOURCE_GROUP --location WestUS
```
2. Erstellen Sie das Speicherkonto:
```
$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. Erstellen eines BLOB-Containers:
```
$BLOB_CONTAINER="velero"
az storage container create -n $BLOB_CONTAINER --public-access off --account-name $AZURE_STORAGE_ACCOUNT_ID
```
  Das Beispiel verwendet einen BLOB-Container mit dem Namen velero. Sie können einen anderen Namen verwenden, vorzugsweise nur für einen einzelnen Kubernetes-Cluster.
Erstellen eines Dienstprinzipals:
1. Rufen Sie die Abonnement-ID und die Mandanten-ID für Ihr Azure-Konto ab:
```
$AZURE_SUBSCRIPTION_ID=(az account list --query '[?isDefault].id' -o tsv)
$AZURE_TENANT_ID=(az account list --query '[?isDefault].tenantId' -o tsv) 
```
2. Erstellen Sie einen Dienstprinzipal mit Mitwirkendenberechtigungen.
  
  Sie können einen Dienstprinzipal mit der Rolle "Mitwirkender" erstellen oder eine benutzerdefinierte Rolle verwenden:
  - Rolle "Mitwirkender": Die Rolle "Mitwirkender" gewährt abonnementweiten Zugriff. Achten Sie daher darauf, diese Anmeldeinformationen zu schützen, wenn Sie diese Rolle zuweisen.
  - Benutzerdefinierte Rolle: Wenn Sie eine restriktivere Rolle benötigen, verwenden Sie eine benutzerdefinierte Rolle.
  Zuweisen der Rolle "Mitwirkender":
  
  Wenn Sie Velero verwenden, um mehrere Cluster mit mehreren BLOB-Containern zu sichern, sollten Sie für jeden Cluster einen eindeutigen Benutzernamen erstellen, anstatt den Namen zu veleroverwenden.
  
  Verwenden Sie den folgenden Befehl, um einen Dienstprinzipal mit der Rolle "Mitwirkender" zu erstellen. Ersetzen Sie Ihre eigene Abonnement-ID und optional Ihren eigenen Dienstprinzipalnamen. Die Microsoft Entra-ID generiert einen geheimen Schlüssel für Sie.
```
$AZURE_CLIENT_SECRET=(az ad sp create-for-rbac --name "velero" --role "Contributor" --query 'password' -o tsv --scopes  /subscriptions/$AZURE_SUBSCRIPTION_ID)
```
  Nehmen Sie bei Bedarf die folgenden Anpassungen am Befehl vor:
  - Wenn Sie beabsichtigen, unterschiedliche Abonnements für Ihren Workloadcluster und Ihre Velero-Sicherungsdateien zu verwenden, stellen Sie beide Abonnement-IDs bereit, wie im folgenden Beispiel gezeigt:
```
$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)
```
  - Wenn Sie nicht als Dienstprinzipalnamen verwenden velero möchten, stellen Sie sicher, dass die --name von Ihnen ausgewählte Id in Microsoft Entra-ID eindeutig ist und keine Konflikte mit anderen Dienstprinzipalen oder App-Registrierungen besteht.
  Wichtig
  
  Der geheime Schlüssel wird nur während dieses Schritts angezeigt, wenn der Dienstprinzipal erstellt wird. Notieren Sie sich unbedingt den geheimen Schlüssel für die Verwendung in zukünftigen Schritten.
  
  Verwenden einer benutzerdefinierten Rolle:
  
  Wenn Sie die minimalen Ressourcenanbieteraktionen aktivieren möchten, erstellen Sie eine benutzerdefinierte Rolle, und weisen Sie diese Rolle dem Dienstprinzipal zu.
  1. Erstellen Sie eine Datei mit dem Namen azure-role.json mit folgendem Inhalt. Ersetzen Sie Ihren eigenen benutzerdefinierten Rollennamen und Ihre Abonnement-ID:
```
{
    "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. Erstellen Sie die benutzerdefinierte Rolle und den Dienstprinzipal:
```
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)
```
  Weitere Informationen zum Erstellen benutzerdefinierter Rollen finden Sie unter Festlegen von Berechtigungen für Velero.
Rufen Sie den Dienstprinzipalnamen ab, und weisen Sie diesen Namen der variablen AZURE_CLIENT_ID zu:
```
$AZURE_CLIENT_ID=(az ad sp list --display-name "velero" --query '[0].appId' -o tsv)
```
Hinweis

Dienstprinzipale laufen ab. Um herauszufinden, wann der neue Dienstprinzipal abläuft, führen Sie den folgenden Befehl aus: az ad sp show --id $AZURE_CLIENT_ID
Erstellen Sie eine Datei, die die Variablen enthält, die die Velero-Installation erfordert. Der Befehl sieht ähnlich wie die folgende aus:
```
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
```
Wichtig

Löschen Sie diese Datei nach der Installation von Velero. Der geheime Clientschlüssel ist nurtext, was ein Sicherheitsrisiko darstellen kann.

Stellen Sie vor dem Fortfahren sicher, dass die Datei ordnungsgemäß formatiert ist. Die Dateinamenerweiterung spielt keine Rolle.
- Entfernen Sie zusätzliche Leerzeichen oder Registerkarten.
- Stellen Sie sicher, dass die Variablennamen korrekt sind.
Installieren und starten Sie Velero.

Installieren Sie Velero auf dem Cluster, und starten Sie die Bereitstellung. Diese Prozedur erstellt einen Namespace namens velero und fügt dem Namespace eine Bereitstellung hinzu velero .
1. Installieren Sie Velero mit dem folgenden Befehl. Sie müssen den Beispielbefehl anpassen.
```
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
```
  Legen Sie die folgenden Variablen nach Bedarf fest:
  - Der Befehl installiert das Microsoft Azure-Plug-In, das mit der von Ihnen verwendeten Velero CLI-Version kompatibel sein muss. Der Beispielbefehl verwendet microsoft Azure Plugin Version 1.5.0, die mit der neuesten Velero CLI-Version 1.9.0 kompatibel ist. Informationen dazu, welche Version des Microsoft Azure-Plug-Ins mit Ihrer Valero CLI-Version installiert werden soll, finden Sie in der Kompatibilitätsmatrix.
  - Achten Sie darauf, den --use-restic Parameter einzuschließen, um die Sicherung von Kubernetes-Volumes auf Dateisystemebene mithilfe Resticvon . Restic kann verwendet werden, um jeden Kubernetes-Volumetyp zu sichern. Standardmäßig unterstützt Velero das Erstellen von Momentaufnahmen persistenter Volumes für Amazon EBS Volumes, Azure Managed Disks und Google Persistent Disks. In AKS Arc verwenden Kubernetes-Volumes Cluster Shared Volumes (CSVs) zum Speichern von Daten. Daher ist erforderlich, Restic um dauerhafte Volumemomentaufnahmen zu aktivieren. AKS Arc unterstützt derzeit keine Volumemomentaufnahmen.
  - subscriptionId=$AZURE_BACKUP_SUBSCRIPTION_ID ist optional. Sie müssen sie nur einschließen, wenn Velero und der Workloadcluster unterschiedliche Abonnement-IDs aufweisen. Wenn sie dasselbe Azure-Abonnement verwenden, können Sie den subscriptionId Parameter entfernen, und die datei credentials-velero.txt stellt diese Informationen bereit.
  Der Velero-Dienst wird automatisch bei der Installation gestartet.
2. Überprüfen Sie, ob der Velero-Dienst ordnungsgemäß ausgeführt wird:
```
kubectl -n velero get pods
kubectl logs deployment/velero -n velero
```
  Der get pods Befehl sollte zeigen, dass die Velero-Pods ausgeführt werden.

Installieren von Velero mit MinIO-Speicher

Die Verfahren in diesem Abschnitt beschreiben, wie Velero installiert und MinIO-Speicher für Sicherungen verwendet wird. Wenn Sie Azure Blob Storage für Ihre Sicherungen verwenden möchten, wechseln Sie zu "Velero mit Azure Blob Storage installieren".

Wenn Sie Ihre Sicherungen nicht in MinIO speichern möchten, wechseln Sie zu "Velero einrichten", um Azure Blob Storage zu verwenden.

Installieren Sie die Velero CLI, indem Sie den folgenden Befehl ausführen. Installieren Sie Chocolately , falls noch nicht geschehen.
```
choco install velero
```

MinIO installieren:

Erstellen Sie ein persistentes Volume zum Speichern der MinIO-Sicherung. Im Beispiel wird ein persistentes Volume in der Standardspeicherklasse in AKS Arc erstellt, das bereits vorhanden ist.

Erstellen Sie eine YAML-Datei namens minio-pvc-storage.yaml mit dem folgenden Inhalt:

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

Erstellen Sie das persistente Volume, indem Sie diesen Befehl ausführen:

kubectl create -f minio-pvc-storage.yaml

Erstellen Sie eine Bereitstellungsdatei, minio-deployment.yaml, zum Starten von MinIO. Fügen Sie den folgenden Inhalt ein. Die Bereitstellung verwendet das von Ihnen erstellte persistente Volume.

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"

Erstellen Sie dann die Bereitstellung:

kubectl create -f minio-deployment.yaml

Erstellen Sie einen Kubernetes-Dienst namens minio-service.yaml. Dieser Dienst stellt externe IP-Adressen für den MinIO-Pod bereit.

Erstellen Sie eine YAML-Datei mit den folgenden Einstellungen, um den Dienst zu konfigurieren:
```
apiVersion: v1 
kind: Service 
metadata: 
name: minio-service 
spec: 
type: LoadBalancer 
ports: 
   - port: 9000 
     targetPort: 9000 
     protocol: TCP 
selector: 
   app: minio 
```
Erstellen Sie dann den Dienst:
```
kubectl create -f mino-service.yaml
```
Rufen Sie die externe IP-Adresse des MinIO-Pods ab, indem Sie den folgenden Befehl ausführen. Sie verwenden diese Adresse, um Velero zu installieren.
```
kubectl get svc
```
Um zu überprüfen, ob MinIO aktiv ist, melden Sie sich bei der IP-Adresse in einem Browser an, oder verwenden Sie den MinIO-Client, wie unten beschrieben.

Installieren Sie den MinIO-Client, und durchsuchen Sie die MinIO-Dateien.

Laden Sie den MinIO-Client herunter:
```
Invoke-WebRequest -Uri "https://dl.minio.io/client/mc/release/windows-amd64/mc.exe" -OutFile "C:\mc.exe
```
Legen Sie als Nächstes einen Alias fest:
```
mc alias set minio http://10.10.77.6:9000 "minio_access_key" "minio_secret_key" --api s3v4
```
Durchsuchen Sie schließlich die MinIO-Installation:
```
mc ls minio
```
Erstellen Sie einen Bucket zum Speichern von Velero-Dateien. Dieser Bucket wird in der Velero-Installation verwendet.
```
mc mb minio/velero-backup
```
Erstellen Sie eine MinIO-Anmeldeinformationsdatei "minio.credentials " mit den folgenden Informationen:
```
[default] 
aws_access_key_id=<minio_access_key> 
aws_secret_access_key=<minio_secret_key> 
```

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

Bevor Sie diesen Befehl ausführen, überprüfen Sie den Bucketnamen, Ihre MinIO-Anmeldeinformationen und die externe IP-Adresse von MinIO.

Überprüfen Sie, ob der Velero-Dienst ordnungsgemäß ausgeführt wird:
```
kubectl -n velero get pods
kubectl logs deployment/velero -n Velero
```
Der get pods Befehl sollte zeigen, dass die Velero-Pods ausgeführt werden.

Sichern eines Clusters

Sie können alle Objekte in Ihrem Cluster sichern oder wiederherstellen, oder Sie können Objekte nach Typ, Namespace und/oder Bezeichnung filtern.

So erstellen Sie eine Sicherung

Verwenden Sie den Velero-Befehl backup create , um Sicherungen für Ihren ausgewählten Speicher zu erstellen. In den folgenden Beispielen wird das --default-volumes-to-restic Flag verwendet, das eine Momentaufnahme der persistenten Volumes erstellt. Weitere Sicherungsoptionen finden Sie in der Velero Backup Reference.

On-Demand-Sicherung aller Namespaces in Ihrem Cluster:

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

On-Demand-Sicherung eines einzelnen Namespaces in Ihrem Cluster:

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

On-Demand-Sicherung mehrerer ausgewählter Namespaces in Ihrem Cluster:

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

Überprüfen des Sicherungsstatus

Führen Sie den folgenden Befehl aus, um den Status einer Sicherung zu überprüfen:
```
velero backup describe <BACKUP-NAME>
```
Wenn Sie Azure Blob Storage für Ihre Sicherungen verwenden, können Sie Ihre Sicherung in Ihrem Azure-Speicherkonto unter dem von Ihnen erstellten Blob/Container anzeigen.

Wiederherstellen eines Clusters

Um einen Cluster wiederherzustellen, müssen Sie einen neuen Cluster erstellen, um den alten Cluster wiederherzustellen. Sie können eine Clustersicherung nicht in einem vorhandenen Cluster wiederherstellen.

Mit dem restore Befehl können Sie alle Objekte und persistenten Volumes aus einer zuvor erstellten Sicherung wiederherstellen. Sie können auch nur eine gefilterte Teilmenge von Objekten und persistenten Volumes wiederherstellen. Weitere Sicherungsoptionen finden Sie unter Ressourcenfilterung.

Auf dem Cluster, auf dem Sie die Sicherung wiederherstellen möchten (der Zielcluster):

Stellen Sie Velero mithilfe der obigen Anweisungen bereit. Verwenden Sie die gleichen Azure-Anmeldeinformationen, die Sie für den Quellcluster verwendet haben.
Stellen Sie sicher, dass das Velero-Sicherungsobjekt erstellt wurde, indem Sie den folgenden Befehl ausführen. Velero-Ressourcen werden mit den Sicherungsdateien im Cloudspeicher synchronisiert.
```
velero backup describe <BACKUP-NAME>
```
Nachdem Sie bestätigt haben, dass die richtige Sicherung (BACKUP-NAME) vorhanden ist, stellen Sie alle Objekte in der Sicherung wieder her:
```
velero restore create --from-backup <BACKUP-NAME>
```

Abrufen von Hilfe zu Velero-Befehlen

Um alle Optionen anzuzeigen, die einem bestimmten Velero-Befehl zugeordnet sind, verwenden Sie das --help Flag mit dem Befehl. velero restore create --help zeigt beispielsweise alle Optionen für den Befehl velero restore create an.

Führen Sie z. B. zum Auflisten aller Optionen von velero restore, ausführen velero restore --help, die die folgenden Informationen zurückgibt:

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

Deinstallieren von Velero

Führen Sie die folgenden Befehle aus, um Velero aus Ihrem Cluster zu deinstallieren und alle von der Velero-Installation erstellten Ressourcen zu entfernen:

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

Freigeben über