Säkerhetskopiera, återställa arbetsbelastningskluster med Velero

Artikel
07/03/2024

Gäller för: AKS på Azure Stack HCI 22H2, AKS på Windows Server

Den här artikeln beskriver hur du installerar och använder Velero för att säkerhetskopiera och återställa arbetsbelastnings- och målkluster med Azure Blob Storage eller MinIO Storage i AKS som aktiveras av Azure Arc.

Velero är ett communitystandardverktyg med öppen källkod för säkerhetskopiering och återställning av Kubernetes-klusterobjekt och beständiga volymer. Den har stöd för olika lagringsleverantörer för att lagra sina säkerhetskopior. Om ett AKS Arc-mål-Kubernetes-kluster kraschar och inte kan återställas kan du använda en Velero-säkerhetskopia för att återställa dess innehåll och interna API-objekt till ett nytt kluster.

Om du inte vill lagra dina säkerhetskopior i Azure Blob Storage kan du använda MinIO med Velero. Den här artikeln beskriver hur du installerar och konfigurerar Velero för att använda Azure Blob Storage eller installera och konfigurera Velero att använda MinIO-lagring.

Kommentar

Velero har inte officiellt stöd för Microsoft Windows. Vid testningen kunde Velero-teamet endast säkerhetskopiera tillståndslösa Windows-program. Restic integrering och säkerhetskopior av tillståndskänsliga program eller beständiga volymer stöds inte.

Förutsättningar

Slutför dessa förutsättningar innan du påbörjar Velero-distributionen:

Installera Azure CLI.
Installera Chocolatey. Du kan använda Chocolatey för att installera Velero-klienten, som innehåller Velero CLI, på en Windows-dator.

Installera Velero med Azure Blob Storage

Procedurerna i det här avsnittet beskriver hur du installerar Velero och använder Azure Blob Storage för säkerhetskopior. Om du inte vill lagra dina säkerhetskopior i Azure går du till Installera Velero med MiniO-lagring.

Öppna PowerShell som administratör.
Logga in på Azure med Hjälp av Azure CLI:
```
az login --use-device-code   
```
Installera Velero CLI genom att köra följande kommando:

Kommentar

Flaggan --use-restic stöds inte i Velero version 1.10 och senare. Flaggan stöds endast på version 1.9.x.
```
choco install velero   
```
Om det behövs ändrar du till den Azure-prenumeration som du vill använda för säkerhetskopiorna.

Som standard lagrar Velero säkerhetskopior i samma Azure-prenumeration som dina virtuella datorer och diskar och tillåter inte att du återställer säkerhetskopior till en resursgrupp i en annan prenumeration. Om du vill aktivera säkerhetskopierings- och återställningsåtgärder mellan prenumerationer anger du en prenumeration som ska användas för dina säkerhetskopior. Du kan hoppa över det här steget om du redan är i den prenumeration som du vill använda för dina säkerhetskopior.

Växla till den prenumeration som du vill använda för dina säkerhetskopior:
1. Använd prenumerationsnamnet för att hitta prenumerations-ID:t:
```
$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. Ändra sedan prenumerationen:
```
az account set -s $AZURE_BACKUP_SUBSCRIPTION_ID
```
Skapa ett Azure Storage-konto och en blobcontainer.

När du använder Azure Blob Storage för säkerhetskopior kräver Velero ett lagringskonto och en blobcontainer för att lagra säkerhetskopiorna. I följande exempel visas lagringskontot som skapats i en ny Velero_Backups resursgrupp.

Du måste skapa lagringskontot med ett globalt unikt ID som kan användas i DNS. Exempelskriptet använder uuidgen appen för att generera ett unikt namn slumpmässigt. Du kan använda valfri metod så länge namnet följer Azures namngivningsregler för lagringskonton.

Lagringskontot skapas med kryptering i vila -funktioner (med hjälp av Microsoft-hanterade nycklar) och är konfigurerat för att endast tillåta åtkomst via HTTPS-anslutningar.

Följ dessa steg för att skapa lagringskontot och blobcontainern:
1. Skapa en resursgrupp för lagringskontot för säkerhetskopiering. Ändra kataloger till önskad plats om det behövs och kör följande kommandon:
```
$AZURE_BACKUP_RESOURCE_GROUP="Velero_Backups"
az group create -n $AZURE_BACKUP_RESOURCE_GROUP --location WestUS
```
2. Skapa lagringskontot:
```
$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. Skapa en blobcontainer:
```
$BLOB_CONTAINER="velero"
az storage container create -n $BLOB_CONTAINER --public-access off --account-name $AZURE_STORAGE_ACCOUNT_ID
```
  I exemplet används en blobcontainer med namnet velero. Du kan använda ett annat namn, helst unikt för ett enda Kubernetes-kluster.
Skapa ett huvudnamn för tjänsten:
1. Hämta prenumerations-ID och klient-ID för ditt Azure-konto:
```
$AZURE_SUBSCRIPTION_ID=(az account list --query '[?isDefault].id' -o tsv)
$AZURE_TENANT_ID=(az account list --query '[?isDefault].tenantId' -o tsv) 
```
2. Skapa ett huvudnamn för tjänsten som har deltagarbehörighet.
  
  Du kan skapa ett huvudnamn för tjänsten med rollen Deltagare eller använda en anpassad roll:
  - Deltagarroll: Deltagarrollen beviljar prenumerationsomfattande åtkomst, så se till att skydda den här autentiseringsuppgiften om du tilldelar rollen.
  - Anpassad roll: Om du behöver en mer restriktiv roll använder du en anpassad roll.
  Tilldela rollen Deltagare:
  
  Om du använder Velero för att säkerhetskopiera flera kluster med flera blobcontainrar kanske du vill skapa ett unikt användarnamn för varje kluster i stället för att använda namnet velero.
  
  Om du vill skapa ett huvudnamn för tjänsten med rollen Deltagare använder du följande kommando. Ersätt ditt eget prenumerations-ID och eventuellt ditt eget huvudnamn för tjänsten. Microsoft Entra-ID genererar en hemlighet åt dig.
```
$AZURE_CLIENT_SECRET=(az ad sp create-for-rbac --name "velero" --role "Contributor" --query 'password' -o tsv --scopes  /subscriptions/$AZURE_SUBSCRIPTION_ID)
```
  Gör dessa justeringar i kommandot om det behövs:
  - Om du planerar att använda olika prenumerationer för ditt arbetsbelastningskluster och dina Velero-säkerhetskopieringsfiler anger du båda prenumerations-ID:na, som i följande exempel:
```
$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)
```
  - Om du inte vill använda velero som tjänstens huvudnamn kontrollerar du att --name du väljer är unikt i Microsoft Entra-ID och inte står i konflikt med andra tjänsthuvudnamn eller appregistreringar.
  Viktigt!
  
  Hemligheten visas bara under det här steget när tjänstens huvudnamn skapas. Se till att anteckna hemligheten för användning i framtida steg.
  
  Använd en anpassad roll:
  
  Om du vill aktivera åtgärder för minsta resursprovider skapar du en anpassad roll och tilldelar rollen till tjänstens huvudnamn.
  1. Skapa en fil med namnet azure-role.json med följande innehåll. Ersätt ditt eget anpassade rollnamn och prenumerations-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. Skapa den anpassade rollen och tjänstens huvudnamn:
```
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)
```
  Mer information om hur du skapar anpassade roller finns i Ange behörigheter för Velero.
Hämta tjänstens huvudnamn och tilldela det namnet till variabeln AZURE_CLIENT_ID :
```
$AZURE_CLIENT_ID=(az ad sp list --display-name "velero" --query '[0].appId' -o tsv)
```
Kommentar

Tjänstens huvudnamn upphör att gälla. Kör det här kommandot för att ta reda på när det nya tjänstens huvudnamn upphör att gälla: az ad sp show --id $AZURE_CLIENT_ID.
Skapa en fil som innehåller variablerna som Velero-installationen kräver. Kommandot ser ut ungefär så här:
```
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
```
Viktigt!

Ta bort den här filen när du har installerat Velero. Klienthemligheten är i klartext, vilket kan utgöra en säkerhetsrisk.

Kontrollera att filen är korrekt formaterad innan du fortsätter. Filnamnstillägget spelar ingen roll.
- Ta bort eventuella extra blanksteg eller flikar.
- Kontrollera att variabelnamnen är korrekta.
Installera och starta Velero.

Installera Velero i klustret och starta distributionen. Den här proceduren skapar ett namnområde med namnet velero och lägger till en distribution med namnet velero till namnområdet.
1. Installera Velero med följande kommando. Du måste anpassa exempelkommandot.
```
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
```
  Ange följande variabler efter behov:
  - Kommandot installerar Plugin-programmet Microsoft Azure, som måste vara kompatibelt med den Velero CLI-version som du använder. Exempelkommandot använder Microsoft Azure plugin version 1.5.0, som är kompatibel med den senaste Velero CLI-versionen, 1.9.0. Information om vilken version av Microsoft Azure-plugin-programmet som ska installeras med valero CLI-versionen finns i kompatibilitetsmatrisen.
  - Se till att inkludera parametern --use-restic för att aktivera säkerhetskopiering av Kubernetes-volymer på filsystemnivå med hjälp av Restic. Restic kan användas för att säkerhetskopiera alla typer av Kubernetes-volymer. Som standard har Velero stöd för att ta ögonblicksbilder av beständiga volymer för Amazon EBS-volymer, Azure Managed Disks och Google Persistent Disks. I AKS Arc använder Kubernetes-volymer klusterdelade volymer (CSV:er) för att lagra data. Restic Därför behövs för att aktivera beständiga ögonblicksbilder av volymer. AKS Arc stöder för närvarande inte volymögonblicksbilder.
  - subscriptionId=$AZURE_BACKUP_SUBSCRIPTION_ID är valfritt. Du behöver bara inkludera den om Velero och arbetsbelastningsklustret har olika prenumerations-ID:t. Om de använder samma Azure-prenumeration kan du ta bort parametern subscriptionId och den credentials-velero.txt filen innehåller den informationen.
  Velero-tjänsten startas automatiskt vid installationen.
2. Kontrollera om Velero-tjänsten körs korrekt:
```
kubectl -n velero get pods
kubectl logs deployment/velero -n velero
```
  Kommandot get pods bör visa att Velero-poddarna körs.

Installera Velero med MinIO-lagring

Procedurerna i det här avsnittet beskriver hur du installerar Velero och använder MinIO-lagring för säkerhetskopior. Om du föredrar att använda Azure Blob Storage för dina säkerhetskopior går du till Installera Velero med Azure Blob Storage.

Om du inte vill lagra dina säkerhetskopior i MinIO går du till Konfigurera Velero för att använda Azure Blob Storage.

Installera Velero CLI genom att köra följande kommando. Installera Chocolately om du inte redan har gjort det.
```
choco install velero
```

Installera MinIO:

Skapa en beständig volym för att lagra MinIO-säkerhetskopieringen. Exemplet skapar en beständig volym i standardlagringsklassen i AKS Arc, som redan finns.

Skapa en YAML-fil med namnet minio-pvc-storage.yaml med följande innehåll:

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

Skapa den beständiga volymen genom att köra det här kommandot:

kubectl create -f minio-pvc-storage.yaml

Skapa en distributionsfil, minio-deployment.yaml, för att starta MinIO. Inkludera följande innehåll. Distributionen använder den beständiga volym som du skapade.

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"

Skapa sedan distributionen:

kubectl create -f minio-deployment.yaml

Skapa en Kubernetes-tjänst med namnet minio-service.yaml. Den här tjänsten tillhandahåller externa IP-adresser till MinIO-podden.

Skapa en YAML-fil med följande inställningar för att konfigurera tjänsten:
```
apiVersion: v1 
kind: Service 
metadata: 
name: minio-service 
spec: 
type: LoadBalancer 
ports: 
   - port: 9000 
     targetPort: 9000 
     protocol: TCP 
selector: 
   app: minio 
```
Skapa sedan tjänsten:
```
kubectl create -f mino-service.yaml
```
Hämta MinIO-poddens externa IP-adress genom att köra följande kommando. Du använder den adressen för att installera Velero.
```
kubectl get svc
```
Om du vill kontrollera om MinIO är igång loggar du in på IP-adressen i en webbläsare eller använder MinIO-klienten enligt beskrivningen nedan.

Installera MinIO-klienten och bläddra igenom MinIO-filerna.

Ladda ned MinIO-klienten:
```
Invoke-WebRequest -Uri "https://dl.minio.io/client/mc/release/windows-amd64/mc.exe" -OutFile "C:\mc.exe
```
Ange sedan ett alias:
```
mc alias set minio http://10.10.77.6:9000 "minio_access_key" "minio_secret_key" --api s3v4
```
Bläddra slutligen igenom MinIO-installationen:
```
mc ls minio
```
Skapa en bucket för att lagra Velero-filer. Den här bucketen används i Velero-installationen.
```
mc mb minio/velero-backup
```

Skapa en MinIO-autentiseringsuppgifter-fil med minio.credentials med följande information:

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

Installera 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

Innan du kör det här kommandot kontrollerar du bucketnamnet, dina MinIO-autentiseringsuppgifter och den externa IP-adressen MinIO.

Kontrollera om Velero-tjänsten körs korrekt:
```
kubectl -n velero get pods
kubectl logs deployment/velero -n Velero
```
Kommandot get pods bör visa att Velero-poddarna körs.

Säkerhetskopiera ett kluster

Du kan säkerhetskopiera eller återställa alla objekt i klustret eller filtrera objekt efter typ, namnområde och/eller etikett.

Skapa en säkerhetskopia

Använd Velero-kommandot backup create för att skapa säkerhetskopior till den valda lagringen. I följande exempel används --default-volumes-to-restic flaggan, som skapar en ögonblicksbild av de beständiga volymerna. Andra säkerhetskopieringsalternativ finns i Referens för Velero-säkerhetskopiering.

Säkerhetskopiering på begäran av alla namnområden i klustret:
```
velero backup create <BACKUP-NAME> --default-volumes-to-restic
```

Säkerhetskopiering på begäran av ett enda namnområde i klustret:

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

Säkerhetskopiering på begäran av flera valda namnområden i klustret:

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

Kontrollera säkerhetskopieringens förlopp

Kör det här kommandot för att kontrollera förloppet för en säkerhetskopia:
```
velero backup describe <BACKUP-NAME>
```
Om du använder Azure Blob Storage för dina säkerhetskopior kan du visa din säkerhetskopia i ditt Azure Storage-konto under den blob/container som du skapade.

Återställa ett kluster

Om du vill återställa ett kluster måste du skapa ett nytt kluster för att återställa det gamla klustret till. Du kan inte återställa en klustersäkerhetskopia till ett befintligt kluster.

Med restore kommandot kan du återställa alla objekt och beständiga volymer från en tidigare skapad säkerhetskopia. Du kan också bara återställa en filtrerad delmängd av objekt och beständiga volymer. Fler säkerhetskopieringsalternativ finns i Resursfiltrering.

I klustret som du vill återställa säkerhetskopian till ( målklustret):

Distribuera Velero med hjälp av anvisningarna ovan. Använd samma Azure-autentiseringsuppgifter som du använde för källklustret.
Kontrollera att Velero-säkerhetskopieringsobjektet skapades genom att köra följande kommando. Velero-resurser synkroniseras med säkerhetskopieringsfilerna i molnlagringen.
```
velero backup describe <BACKUP-NAME>
```
När du har bekräftat att rätt säkerhetskopia (BACKUP-NAME) finns återställer du alla objekt i säkerhetskopian:
```
velero restore create --from-backup <BACKUP-NAME>
```

Få hjälp med Velero-kommandon

Om du vill se alla alternativ som är associerade med ett specifikt Velero-kommando använder du --help flaggan med kommandot . Visar till exempel velero restore create --help alla alternativ som är associerade med velero restore create kommandot.

Om du till exempel vill visa en lista över alla alternativ för velero restorekör velero restore --helpdu , som returnerar följande information:

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

Avinstallera Velero

Om du vill avinstallera Velero från klustret och ta bort alla resurser som skapats av Velero-installationen kör du följande kommandon:

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

Dela via