Virtuelle Maschinen verwalten

Auf dieser Seite wird beschrieben, wie Sie virtuelle Maschinen in Ihrer mit Google Distributed Cloud verbundenen Bereitstellung verwalten, auf der VM Runtime on Google Distributed Cloud ausgeführt wird. Sie müssen mit der VM Runtime on GDC vertraut sein, bevor Sie die Schritte auf dieser Seite ausführen. Eine Liste der unterstützten Gastbetriebssysteme finden Sie unter Verifizierte Gastbetriebssysteme für VM Runtime auf GDC.

Informationen dazu, wie virtuelle Maschinen als wesentliche Komponente der verbundenen Plattform von Distributed Cloud dienen, finden Sie unter GKE Enterprise erweitern, um lokale Edge-VMs zu verwalten.

Distributed Cloud Connected Clusters unterstützen Webhooks für virtuelle Maschinen. So kann Distributed Cloud Connected Nutzeranfragen, die an den lokalen Kubernetes API-Server gesendet werden, validieren. Bei abgelehnten Anfragen werden detaillierte Informationen zum Ablehnungsgrund generiert.

Symcloud Storage konfigurieren

Google Distributed Cloud Connected verwendet Rakuten Symcloud Storage als Speicherlösung. Symcloud Storage ist eine Drittanbieterlösung, die auf jedem Distributed Cloud Connected-Knoten als Abstraktionsebene für den lokalen Speicher fungiert und den lokalen Speicher für Arbeitslasten verfügbar macht, die auf anderen Distributed Cloud Connected-Knoten ausgeführt werden.

Symcloud Storage wird über den Google Cloud Marketplace bereitgestellt und unterliegt den dort angegebenen Bedingungen. Google bietet nur eingeschränkten Support für die Verwendung von Symcloud Storage mit Distributed Cloud Connected und wendet sich möglicherweise an den Drittanbieter, um Unterstützung zu erhalten. Softwareupdates für Symcloud Storage sind in den Softwareupdates für Distributed Cloud enthalten.

Konfigurieren Sie Ihren mit Google Distributed Cloud verbundenen Cluster so, dass Symcloud Storage für virtuelle Maschinen aktiviert wird. Weitere Informationen finden Sie unter Symcloud Storage auf einem mit Distributed Cloud verbundenen Knoten installieren.

  1. Erstellen Sie den Namespace robin-admin mit dem folgenden Befehl:

    kubectl create ns robin-admin

  2. Rufen Sie die Symcloud Storage-Lizenzdatei ab und wenden Sie sie mit dem folgenden Befehl auf den Cluster an:

    kubectl apply LICENSE_FILE

  3. Prüfen Sie mit dem folgenden Befehl, ob Symcloud Storage ausgeführt wird:

    kubectl describe robincluster

    Die Ausgabe des Befehls sieht in etwa so aus:

     Name:         robin
 Namespace:
 Labels:       app.kubernetes.io/instance=robin
               app.kubernetes.io/managed-by=robin.io
               app.kubernetes.io/name=robin
 Annotations:  <none>
 API Version:  manage.robin.io/v1
 Kind:         RobinCluster
 Metadata:
   …
 Spec:
   …
 Status:
   …
   Phase:             Ready
   …

  4. Erstellen Sie die StorageClass robin-block-immediate, indem Sie die folgende Konfiguration auf den Cluster anwenden:

    apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: robin-block-immediate
parameters:
  faultdomain: host
  replication: "3"
  blocksize:   "512"
provisioner: robin
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true

  5. Erstellen Sie die robin-snapshotclass-VolumeSnapshotClass, indem Sie die folgende Konfiguration auf den Cluster anwenden:

    apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: robin-snapshotclass
  labels:
    app.kubernetes.io/instance: robin
    app.kubernetes.io/managed-by: robin.io
    app.kubernetes.io/name: robin
  annotations:
    snapshot.storage.kubernetes.io/is-default-class: "true"
driver: robin
deletionPolicy: Delete

  6. Ändern Sie das storageprofile für die Speicherklasse robin-block-immediate mit dem folgenden Inhalt und wenden Sie es auf Ihren Cluster an:

    apiVersion: cdi.kubevirt.io/v1beta1
kind: StorageProfile
metadata:
  name: robin-block-immediate
spec:
  claimPropertySets:
    accessModes:
      ReadWriteMany
  volumeMode: Block

virtctl-Verwaltungstool installieren

Sie benötigen das Clienttool virtctl, um virtuelle Maschinen in Ihrem mit Distributed Cloud verbundenen Cluster zu verwalten. So installieren Sie das Tool:

  1. Installieren Sie das virtctl-CLienttool als kubectl-Plug-in.

    export VERSION=GDC_SO_VERSION
gcloud storage cp gs://anthos-baremetal-release/virtctl/${VERSION}/linux-amd64/virtctl ./virtctl
sudo mv ./virtctl /usr/local/bin/virtctl
cd /usr/local/bin
sudo ln -s virtctl kubectl-virt
sudo chmod a+x virtctl
cd -

    Ersetzen Sie GDC_SO_VERSION durch die Zielversion von Distributed Cloud Software-Only.

  2. Überprüfen Sie, ob das Plug-in virt installiert ist:

    kubectl plugin list

    Wenn das Plug-in erfolgreich installiert wurde, wird kubectl-virt in der Ausgabe des Befehls als eines der Plug-ins aufgeführt.

Cloud Storage-Bucket für VM-Images erstellen

Führen Sie die Schritte in diesem Abschnitt aus, um einen Cloud Storage-Bucket für Ihre VM-Images zu erstellen. Für den Bucket wird die Workload Identity-Föderation verwendet, um ein Kubernetes-Dienstkonto an das entsprechende Google Cloud -Dienstkonto zu binden, damit auf den Bucket zugegriffen werden kann. Das Kubernetes-Dienstkonto übernimmt also die Identität des Google Cloud-Dienstkontos. Wenn Sie bereits ein Image-Repository haben, überspringen Sie diesen Abschnitt.

Um das Risiko von identischen Identitäten in einer Multi-Cluster-Flotte zu verringern, folgen Sie den Richtlinien unter Best Practices für die Workload Identity Federation von Flotten, wenn Sie die Schritte in diesem Abschnitt ausführen.

  1. Führen Sie die Schritte unter Buckets erstellen aus, um einen Bucket zu erstellen.

  2. Erstellen Sie ein Google Cloud Dienstkonto für den Zugriff auf den Bucket:

    export GSA_PROJECT_ID=GSA_PROJECT_ID
export GSA_NAME=GSA_NAME
gcloud iam service-accounts create ${GSA_NAME}

    Ersetzen Sie Folgendes:

    • GSA_NAME: Ein aussagekräftiger Name für dieses Google Cloud Dienstkonto.
    • GSA_PROJECT_ID: die ID des Google Cloud Projekts, in dem sich das Ziel-Google Cloud Dienstkonto befindet.

  3. Gewähren Sie dem Dienstkonto Google Cloud Berechtigungen für den Zugriff auf den Bucket:

    export BUCKET_PROJECT_ID=BUCKET_PROJECT_ID
export GSA_NAME=GSA_NAME
gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
   --member="serviceAccount:${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/storage.objectViewer" \
   --project=${BUCKET_PROJECT_ID}

    Ersetzen Sie Folgendes:

    • GSA_NAME: der Name des Ziel- Google Cloud Dienstkontos.
    • BUCKET_PROJECT_ID: Die ID des Google Cloud -Projekts, in dem sich der Bucket befindet.
    • GSA_PROJECT_ID: die ID des Google Cloud Projekts, in dem sich das Ziel-Google Cloud Dienstkonto befindet.

  4. Erstellen Sie ein Kubernetes-Dienstkonto im Namespace der Ziel-VM, das an Ihr Google Cloud -Dienstkonto gebunden werden soll:

    export GSA_PROJECT_ID=GSA_PROJECT_ID
export VM_NAMESPACE=NAMESPACE
export KSA_NAME=KSA_NAME
export GSA_EMAIL=${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com
kubectl create serviceaccount ${KSA_NAME} -n ${VM_NAMESPACE}
kubectl annotate serviceaccount ${KSA_NAME} gsaEmail=${GSA_EMAIL} -n ${VM_NAMESPACE}

    Ersetzen Sie Folgendes:

    • GSA_PROJECT_ID: die ID des Google Cloud Projekts, in dem sich das Ziel-Google Cloud Dienstkonto befindet.
    • NAMESPACE: der Namespace der Ziel-VM.
    • KSA_NAME: Ein aussagekräftiger Name für dieses Kubernetes-Dienstkonto.
    • GSA_NAME: der Name des entsprechenden Google Cloud Dienstkontos.

  5. Ermitteln Sie den Namen des Workload Identity-Pools und des Identitätsanbieters Ihres Clusters:

    gcloud container fleet memberships describe MEMBERSHIP_ID \
    --project=FLEET_PROJECT_ID \
    --format="table(authority.identityProvider,authority.workloadIdentityPool,name)"

    Ersetzen Sie Folgendes:

    • MEMBERSHIP_ID: Der Name der Flottenmitgliedschaft des Clusters. Das ist in der Regel der Name Ihres Clusters.
    • FLEET_PROJECT_ID: die ID des Google Cloud Flotten-Hostprojekts.

    Die Ausgabe des Befehls sieht in etwa so aus:

    IDENTITY_PROVIDER: IDENTITY_PROVIDER
WORKLOAD_IDENTITY_POOL: WORKLOAD_IDENTITY_POOL

    Notieren Sie sich in der Ausgabe die folgenden Werte:

  6. Binden Sie das Kubernetes-Dienstkonto an das Google Cloud -Dienstkonto, um die Identitätsübernahme einzurichten:

    export GSA_PROJECT_ID=GSA_PROJECT_ID
export GSA_NAME=GSA_NAME
export KSA_NAME=KSA_NAME
export VM_NAMESPACE=NAMESPACE
export WI_POOL=WORKLOAD_IDENTITY_POOL
gcloud iam service-accounts add-iam-policy-binding ${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com \
   --project=${GSA_PROJECT_ID} \
   --role=roles/iam.workloadIdentityUser \
   --member="serviceAccount:${WI_POOL}[${VM_NAMESPACE}/${KSA_NAME}]"
   --condition="IAM_CONDITION"
   --condition-from-file="IAM_CONDITION_FILE"

    Ersetzen Sie Folgendes:

    • GSA_PROJECT_ID: die ID des Google Cloud Projekts, in dem sich das Ziel-Google Cloud Dienstkonto befindet.
    • GSA_NAME: der Name des entsprechenden Google Cloud Dienstkontos.
    • KSA_NAME: Der Name des Ziel-Kubernetes-Dienstkontos.
    • NAMESPACE: der Namespace der Ziel-VM.
    • WORKLOAD_IDENTITY_POOL: der Name des Workload Identity-Pools Ihres Clusters.
    • IAM_CONDITION: optional; gibt die IAM-Bedingungen an, mit denen der Zugriff auf bestimmte Cluster in der Flotte eingeschränkt werden soll. Wenn es weggelassen oder auf None gesetzt wird, gelten keine IAM-Bedingungen.
    • IAM_CONDITION_FILE: optional; gibt die Datei mit den IAM-Bedingungen an, die verwendet werden sollen, um den Zugriff auf bestimmte Cluster in der Flotte einzuschränken. Wird es weggelassen, gelten keine IAM-Bedingungen, es sei denn, das Flag --condition ist angegeben und auf einen anderen Wert als None gesetzt.

  7. Speichern Sie Ihre Bilder im Bucket.

Sie haben auch die Möglichkeit, die alte Methode mit einem Secret zu verwenden, das aus dem aktiven Schlüssel Ihres Google-Dienstkontos generiert wird. Weitere Informationen finden Sie unter Cloud Storage-Bucket für VM-Images erstellen.

Zugriff auf den Bucket mit IAM-Bedingungen einschränken

Mit IAM-Bedingungen können Sie angeben, welche Cluster in der Flotte auf den Bucket zugreifen können. Wenn keine IAM-Bedingungen angegeben sind, können alle Cluster in der Flotte mit demselben Kubernetes-Dienstkonto im selben Namespace auf den Bucket zugreifen, was ein Risiko in Bezug auf die Identitätsgleichheit darstellt. Wenn Sie keine IAM-Bedingungen angeben, können Sie auch auf den alten Zugriffsmechanismus zurückgreifen, bei dem ein Secret verwendet wird, das aus dem aktiven Schlüssel eines Google-Dienstkontos generiert wird. Im Folgenden finden Sie ein Beispiel dafür, wie Sie IAM Conditions einrichten und anwenden, um den Zugriff auf Ihren Bucket einzuschränken:

  1. Erstellen Sie die IAM-Bedingungsdatei:

    cat <<EOF > iam_condition.yaml
> expression: request.auth.claims.google.providerId == '$IDENTITY_PROVIDER'
title: allow_only_this_cluster
> EOF

  2. Wenden Sie die IAM-Bedingungsdatei an, wenn Sie das GSA an das KSA binden. Führen Sie den folgenden Befehl in Ihrem GSA Google Cloud -Projekt aus:

    gcloud iam service-accounts add-iam-policy-binding "${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com" \
  --project="${GSA_PROJECT_ID}" \
  --role=roles/iam.workloadIdentityUser \
  --member="serviceAccount:${WI_POOL}[${VM_NAMESPACE}/${KSA_NAME}]" \
  --condition-from-file=iam_condition.yaml

VM-Laufwerk aus einem VM-Image erstellen

Führen Sie die Schritte in diesem Abschnitt aus, um ein VM-Laufwerk aus einem VM-Image zu erstellen.

Laufwerk aus einem in Cloud Storage gespeicherten Image erstellen

Erstellen Sie ein VM-Laufwerk aus einer VM, die in Ihrem Cloud Storage-Bucket gespeichert ist, indem Sie die folgende Konfiguration auf Ihren Cluster anwenden:

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   source:
     gcs:
       url: gs://${BUCKET_PROJECT_ID}-vm-images/IMAGE_FILE_PATH
       serviceAccount: KSA_NAME
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Ersetzen Sie Folgendes:

  • DISK_NAME: der Name dieses VM-Laufwerks.
  • NAMESPACE: der Namespace der Ziel-VM.
  • IMAGE_FILE_PATH: Der vollständige Pfad und Name der VM-Image-Datei. Klicken Sie mit der rechten Maustaste auf das Bild in der Google Cloud Console und wählen Sie gsutil-URI kopieren aus, um diesen Pfad zu erhalten.
  • KSA_NAME: Das Kubernetes-Dienstkonto zum Herunterladen von VM-Images, die Sie zuvor erstellt haben.
  • DISK_SIZE: Die Größe des Ziellaufwerks. Dieser Wert muss größer sein als der virtual-size-Wert der VM-Image-Datei. Sie können diesen Wert mit dem Befehl qemu-img info DISK_SIZE abrufen.

Wenn Sie keinen storageClassName-Wert angeben, wird der Standardwert verwendet, der in der VMRuntime-Ressource angegeben ist.

Laufwerk aus einem Image erstellen, das auf einem Drittanbieterdienst gespeichert ist

Sie haben auch die Möglichkeit, http, https, S3 oder eine Image-Registry zum Speichern Ihrer VM-Images zu verwenden. Wenn für den Zugriff auf Ihren Speicherdienst Anmeldedaten erforderlich sind, wandeln Sie diese Anmeldedaten in ein Secret um und geben Sie dieses Secret mit dem Feld secretRef an. Beispiel:

source:
    http/s3/registry:
       url: 
       secretRef: "SECRET_NAME" # optional

Ersetzen Sie SECRET_NAME durch den Namen Ihres Secrets.

Weitere Informationen finden Sie unter HTTP/S3/GCS/Registry-Quelle.

Leeres Laufwerk erstellen

Erstellen Sie ein leeres VM-Laufwerk, indem Sie die folgende Konfiguration auf Ihren Cluster anwenden:

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Ersetzen Sie Folgendes:

  • DISK_NAME: der Name dieses VM-Laufwerks.
  • NAMESPACE: der Ziel-Namespace.
  • DISK_SIZE: Die gewünschte Laufwerkgröße in Gibibyte. Dieser Wert muss größer sein als der virtual-size-Wert der VM-Image-Datei. Sie können diesen Wert mit dem Befehl qemu-img info DISK_SIZE abrufen.

Wenn Sie keinen storageClassName-Wert angeben, wird der Standardwert verwendet, der in der VMRuntime-Ressource angegeben ist.

Virtuelles Netzwerk konfigurieren

Folgen Sie der Anleitung unter Networking, um das virtuelle Netzwerk für Ihre virtuellen Maschinen zu konfigurieren.

Virtuelle Maschine erstellen

Führen Sie die Schritte in diesem Abschnitt aus, um eine VM auf Ihrer Serverbereitstellung mit Distributed Cloud-Verbindung zu erstellen. Die Anleitungen in diesem Abschnitt sind Beispiele, die Konfigurationen für verschiedene Szenarien veranschaulichen sollen. Ausführliche Informationen zum Konfigurieren von VMs finden Sie unter Mit VM Runtime on GDC eine VM mit bestimmten CPU- und Arbeitsspeicherressourcen erstellen.

Virtuelle Maschine mit der Google Cloud Console erstellen

So erstellen Sie eine virtuelle Maschine mit der Google Cloud Console:

  1. Rufen Sie in der Google Cloud Console die Seite Cluster auf.

    Zu den Clustern

  2. Wählen Sie das Zielprojekt Google Cloud aus.

  3. Optional: Melden Sie sich im Zielcluster an, falls Sie dies noch nicht getan haben:

    1. Klicken Sie im linken Navigationsbereich auf Cluster.

    2. Klicken Sie in der Liste Von Anthos verwaltete Cluster auf den Zielcluster.

    3. Klicken Sie im Informationsbereich auf der rechten Seite auf ANMELDEN.

    4. Wählen Sie im angezeigten Pop-up-Dialogfeld Ihre bevorzugte Authentifizierungsmethode aus, geben Sie Ihre Anmeldedaten ein und klicken Sie auf ANMELDEN.

  4. Rufen Sie die Seite Virtuelle Maschinen auf.

    Zu Virtual Machines

  5. Klicken Sie auf ERSTELLEN.

  6. Führen Sie im Abschnitt Grundlagen folgende Schritte aus:

    1. Geben Sie im Feld Name einen aussagekräftigen Namen für die VM ein.

    2. Wählen Sie im Feld Cluster auswählen den Zielcluster für die virtuelle Maschine aus.

    3. Wählen Sie im Feld Namespace den Ziel-Namespace aus.

    4. Wählen Sie im Feld Betriebssystemtyp das Zielbetriebssystem aus.

    5. Optional: Wenn Sie der Konfiguration dieser virtuellen Maschine ein oder mehrere Labels hinzufügen möchten, klicken Sie auf LABEL HINZUFÜGEN.

  7. Führen Sie im Abschnitt Maschinenkonfiguration einen der folgenden Schritte aus:

    • Wenn Sie die Anzahl der vCPUs und die Größe des Arbeitsspeichers für diese virtuelle Maschine angeben möchten, wählen Sie Benutzerdefinierte Konfiguration aus, geben Sie die Zielwerte ein und klicken Sie auf WEITER.

    • Wenn Sie eine bestimmte Anzahl von vCPUs und eine bestimmte Menge an Arbeitsspeicher für diese virtuelle Maschine verwenden möchten, wählen Sie Standardkonfiguration aus und wählen Sie in der Drop-down-Liste Maschinentyp eine Maschinenkonfiguration aus. Klicken Sie dann auf WEITER.

  8. Führen Sie im Abschnitt Speicher einen der folgenden Schritte aus:

    • Wenn Sie ein neues virtuelles Laufwerk für diese VM erstellen möchten, wählen Sie Neues Laufwerk hinzufügen aus und geben Sie im Feld Name einen aussagekräftigen Namen, im Feld GiB eine Größe in Gigabyte und im Feld Image eine URL ein.

    • Wenn Sie ein vorhandenes virtuelles Laufwerk für diese VM verwenden möchten, wählen Sie Vorhandenes Laufwerk auswählen aus und wählen Sie das Ziellaufwerk-Image aus der Drop-down-Liste Laufwerk auswählen aus.

    • Geben Sie mit den Kästchen Schreibgeschützt und Automatisch löschen an, ob das Laufwerk schreibgeschützt sein soll und ob es automatisch gelöscht wird, wenn diese VM gelöscht wird.

    • Geben Sie in der Drop-down-Liste Treiber einen virtuellen Festplattentreiber an.

    • Wenn Sie dieser VM ein weiteres Laufwerk hinzufügen möchten, klicken Sie im Bereich Zusätzliche Laufwerke auf LAUFWERK HINZUFÜGEN.

    • Tippen Sie auf Weiter.

  9. Führen Sie im Abschnitt Netzwerk folgende Schritte aus:

    1. Geben Sie im Unterabschnitt Standardnetzwerkschnittstelle im Feld Schnittstellenname den Namen der primären Netzwerkschnittstelle für diese virtuelle Maschine an.

    2. Wählen Sie in der Drop-down-Liste Network type (Netzwerktyp) den entsprechenden Netzwerktyp aus.

    3. Geben Sie mit dem Kästchen Externen Zugriff erlauben an, ob der externe Zugriff auf diese Netzwerkschnittstelle zulässig sein soll. Wenn Sie diese Option aktivieren, müssen Sie im Feld Exposed ports (Freigegebene Ports) eine durch Kommas getrennte Liste der Ports eingeben, die extern freigegeben werden sollen.

    4. Wenn Sie dieser VM eine oder mehrere sekundäre Netzwerkschnittstellen hinzufügen möchten, klicken Sie auf NETZWERKSCHNITTSTELLE HINZUFÜGEN.

    5. Tippen Sie auf Weiter.

  10. Geben Sie im Abschnitt Erweiterte Optionen mit dem Kästchen Automatischer Neustart bei Update an, ob diese virtuelle Maschine neu gestartet werden soll, nachdem die mit
    Distributed Cloud verbundene Software im Zielcluster aktualisiert wurde.

  11. Führen Sie im Abschnitt Firmware folgende Schritte aus:

    1. Wählen Sie im Feld Bootloader-Typ den Zielfirmwaretyp aus. Wenn Sie UEFI-Firmware auswählen, können Sie Secure Boot mit dem Kästchen Secure Boot aktivieren.

    2. Geben Sie im Feld Serial eine Seriennummer für diese virtuelle Maschine an.

    3. Geben Sie im Feld UUID eine Universally Unique Identifier (UUID) für diese virtuelle Maschine an.

  12. Führen Sie im Abschnitt Cloud-init die folgenden Schritte aus:

    • Geben Sie im Feld Secret der Netzwerkdaten einen Secret-Wert für die Netzwerkdaten an.

    • Geben Sie im Feld Secret für Nutzerdaten einen Secret-Wert für Nutzerdaten an.

  13. Klicken Sie auf VM ERSTELLEN, um die virtuelle Maschine zu erstellen.

Virtuelle Maschine aus einer YAML-Datei erstellen

So erstellen Sie eine VM aus einer YAML-Konfigurationsdatei:

  1. Rufen Sie in der Google Cloud Console die Seite Cluster auf.

    Zu den Clustern

  2. Wählen Sie das Zielprojekt Google Cloud aus.

  3. Optional: Melden Sie sich im Zielcluster an, falls Sie dies noch nicht getan haben:

    1. Klicken Sie im linken Navigationsbereich auf Cluster.

    2. Klicken Sie in der Liste Von Anthos verwaltete Cluster auf den Zielcluster.

    3. Klicken Sie im Informationsbereich auf der rechten Seite auf ANMELDEN.

    4. Wählen Sie im angezeigten Pop-up-Dialogfeld Ihre bevorzugte Authentifizierungsmethode aus, geben Sie Ihre Anmeldedaten ein und klicken Sie auf ANMELDEN.

  4. Rufen Sie die Seite Virtuelle Maschinen auf.

    Zu Virtual Machines

  5. Klicken Sie auf MIT YAML ERSTELLEN.

  6. Wählen Sie im Feld Cluster auswählen den Zielcluster für die virtuelle Maschine aus.

  7. Fügen Sie die Konfiguration der virtuellen Maschine im YAML-Format in das YAML-Feld ein.

  8. Klicken Sie auf ERSTELLEN.

VM aus einem bootfähigen Laufwerk-Image erstellen

Wenn Sie eine VM aus einem bootfähigen Laufwerk-Image erstellen möchten, wenden Sie die folgende Konfiguration auf Ihren Cluster an:

kind: VirtualMachine
metadata:
  name: my-virtual-machine
  namespace: my-vm-namespace
spec:
  osType: Linux/Windows
  guestEnvironment: {} // comment out this line to enable guest environment for access management
  compute:
    cpu:
      vcpus: 6
    memory:
      capacity: 8Gi
  interfaces:
      - name: eth0
        networkName: network-410
        ipAddresses:
        - 10.223.237.10/25
  disks:
    - virtualMachineDiskName: my-boot-disk
      boot: true
    - virtualMachineDiskName: my-data-disk

Ersetzen Sie Folgendes:

  • DISK_NAME: der Name dieses VM-Laufwerks.
  • NAMESPACE: der Ziel-Namespace.

VM aus einem ISO-Image einer optischen Disc erstellen

Wenn Sie eine VM aus einem ISO-Image einer optischen Disc erstellen möchten, führen Sie die Schritte unter Windows-VM aus einem ISO-Image in Google Distributed Cloud erstellen aus.

Virtuelle Maschine mit GPU-Unterstützung erstellen

Führen Sie die auf dieser Seite beschriebenen Schritte aus, um eine virtuelle Maschine zu erstellen, die Ihren geschäftlichen Anforderungen entspricht. Führen Sie dann die Schritte unter Virtuelle Maschine für die Verwendung von GPU-Ressourcen konfigurieren aus.

Auf eine virtuelle Maschine zugreifen

Führen Sie die Schritte in diesem Abschnitt aus, um auf eine virtuelle Maschine zuzugreifen, die auf Ihrer mit Distributed Cloud verbundenen Serverbereitstellung ausgeführt wird.

Anmeldedaten abrufen

Wenn Sie noch keine Anmeldedaten für den Zugriff auf die virtuelle Maschine haben, führen Sie die Schritte in diesem Abschnitt aus, um sie mithilfe der Linux-Gastumgebung zu erhalten.

  1. Aktivieren Sie die Linux-Gastumgebung für die Ziel-VM, indem Sie die folgende Konfiguration auf Ihren Cluster anwenden:

    kind: VirtualMachine
metadata:
 name: my-virtual-machine
 namespace: my-vm-namespace
spec:
 osType: Linux
 guestEnvironment: // enabled by default; disable with guestEnvironment: {}
   accessManagement:
    enable: true

  2. Generieren Sie mit dem folgenden Befehl eine id_rsa.pub-Datei, die ein SSH-Schlüsselpaar enthält:

    ssh-keygen -t rsa

  3. Erstellen Sie eine VirtualMachineAccessRequest-Ressource, indem Sie die folgende Konfiguration auf Ihren Cluster anwenden:

    apiVersion: vm.cluster.gke.io/v1alpha1
kind: VirtualMachineAccessRequest
metadata:
 name: RESOURCE_NAME
 namespace: NAMESPACE
spec:
  vm: VM_NAME
  user: USER_NAME
  ssh:
    key: RSA_KEY
    ttl: 2h

Ersetzen Sie Folgendes:

  • RESOURCE_NAME: Ein beschreibender Name für diese Ressource der VM-Zugriffsanfrage.
  • NAMESPACE: der Ziel-Namespace.
  • VM_NAME ist der Name der Ziel-VM.
  • USER_NAME: der Name des Nutzers, dem Zugriff gewährt wird.
  • RSA_KEY: der Inhalt der Datei id_rsa.pub, die Sie im vorherigen Schritt generiert haben.

  1. Prüfen Sie den Status der Zugriffsanfrage mit dem folgenden Befehl:

    kubectl get vmar

    Wenn der Befehl den Status Configured zurückgibt, fahren Sie mit dem nächsten Schritt fort.

  2. Mit SSH oder Remote Desktop auf die virtuelle Maschine zugreifen:

    • Wenn die VM mit Ihrem lokalen Netzwerk verbunden ist, können Sie direkt darauf zugreifen.
    • Wenn die VM mit dem Pod-Netzwerk verbunden ist, müssen Sie einen Load-Balancer-Dienst erstellen, um auf die erforderlichen Ports zuzugreifen.

Virtuelle Maschine starten, neu starten oder stoppen

Verwenden Sie die folgenden Befehle, um eine virtuelle Maschine zu starten, neu zu starten oder zu beenden:

  • Virtuelle Maschine starten:kubectl virt start vmVM_NAME-nNAMESPACE
  • Virtuelle Maschine neu starten:kubectl virt restart vmVM_NAME-nNAMESPACE
  • Virtuelle Maschine beenden:kubectl virt stop vmVM_NAME-nNAMESPACE

Ersetzen Sie Folgendes:

  • VM_NAME ist der Name der Ziel-VM.
  • NAMESPACE: der Ziel-Namespace.

Virtuelle Maschine über die Google Cloud Console starten oder stoppen

  1. Rufen Sie in der Google Cloud Console die Seite Cluster auf.

    Zu den Clustern

  2. Wählen Sie das Zielprojekt Google Cloud aus.

  3. Optional: Melden Sie sich im Zielcluster an, falls Sie dies noch nicht getan haben:

    1. Klicken Sie im linken Navigationsbereich auf Cluster.

    2. Klicken Sie in der Liste Von Anthos verwaltete Cluster auf den Zielcluster.

    3. Klicken Sie im Informationsbereich auf der rechten Seite auf ANMELDEN.

    4. Wählen Sie im angezeigten Dialogfeld Ihre bevorzugte Authentifizierungsmethode aus, geben Sie Ihre Anmeldedaten ein und klicken Sie auf ANMELDEN.

  4. Rufen Sie die Seite Virtuelle Maschinen auf.

    Zu Virtual Machines

  5. Wählen Sie in der Liste der virtuellen Maschinen die Kästchen für die Ziel-VMs aus.

  6. Klicken Sie oben auf der Seite auf START oder STOP.

Status einer virtuellen Maschine mit der Google Cloud Console aufrufen

  1. Rufen Sie in der Google Cloud Console die Seite Cluster auf.

    Zu den Clustern

  2. Wählen Sie das Zielprojekt Google Cloud aus.

  3. Optional: Melden Sie sich im Zielcluster an, falls Sie dies noch nicht getan haben:

    1. Klicken Sie im linken Navigationsbereich auf Cluster.

    2. Klicken Sie in der Liste Von Anthos verwaltete Cluster auf den Zielcluster.

    3. Klicken Sie im Informationsbereich auf der rechten Seite auf ANMELDEN.

    4. Wählen Sie im angezeigten Pop-up-Dialogfeld Ihre bevorzugte Authentifizierungsmethode aus, geben Sie Ihre Anmeldedaten ein und klicken Sie auf ANMELDEN.

  4. Rufen Sie die Seite Virtuelle Maschinen auf.

    Zu Virtual Machines

  5. Klicken Sie auf die Ziel-VM.

  6. Klicken Sie auf der angezeigten Seite auf die Tabs Details, Ereignisse und YAML, um die entsprechenden Informationen zu dieser virtuellen Maschine aufzurufen.

Virtuelle Maschine ändern

Wenn Sie eine VM ändern möchten, müssen Sie sie löschen und mit der aktualisierten Konfiguration neu erstellen.

Virtuelle Maschine mit der Google Cloud Console löschen

  1. Rufen Sie in der Google Cloud Console die Seite Cluster auf.

    Zu den Clustern

  2. Wählen Sie das Zielprojekt Google Cloud aus.

  3. Optional: Melden Sie sich im Zielcluster an, falls Sie dies noch nicht getan haben:

    1. Klicken Sie im linken Navigationsbereich auf Cluster.

    2. Klicken Sie in der Liste Von Anthos verwaltete Cluster auf den Zielcluster.

    3. Klicken Sie im Informationsbereich auf der rechten Seite auf ANMELDEN.

    4. Wählen Sie im angezeigten Dialogfeld Ihre bevorzugte Authentifizierungsmethode aus, geben Sie Ihre Anmeldedaten ein und klicken Sie auf ANMELDEN.

  4. Rufen Sie die Seite Virtuelle Maschinen auf.

    Zu Virtual Machines

  5. Klicken Sie in der Liste der virtuellen Maschinen das Kästchen für die Ziel-VM an.

  6. Klicken Sie oben auf der Seite auf LÖSCHEN.

  7. Geben Sie im nun eingeblendeten Bestätigungsdialog den Namen der virtuellen Maschine ein und klicken Sie auf LÖSCHEN.

Virtuelle Maschine sichern

In diesem Abschnitt wird beschrieben, wie Sie Ihre Umgebung für die Sicherung Ihrer Arbeitslasten für virtuelle Maschinen konfigurieren und wie Sie Ihre Sicherungen verwalten. Wenden Sie sich an Ihren Google-Ansprechpartner, um diese Funktion zu aktivieren.

Vorbereitung

  1. Falls noch nicht geschehen, erstellen Sie die benutzerdefinierte Ressource robin-block-immediate vom Typ StorageClass mit dem folgenden Inhalt und wenden Sie sie auf Ihren Cluster an:

    apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
 name: robin-block-immediate
 annotations:
   storageclass.kubernetes.io/is-default-class: "true"
parameters:
 faultdomain: host
 replication: "3"
 blocksize:   "512"
provisioner: robin
reclaimPolicy: Delete
volumeBindingMode: Immediate

  2. Falls noch nicht geschehen, erstellen Sie eine benutzerdefinierte robin-snapshotclass-Ressource vom Typ VolumeSnapshotClass mit dem folgenden Inhalt und wenden Sie sie auf Ihren Cluster an:

    apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
 name: robin-snapshotclass
 labels:
   app.kubernetes.io/instance: robin
   app.kubernetes.io/managed-by: robin.io
   app.kubernetes.io/name: robin
 annotations:
   snapshot.storage.kubernetes.io/is-default-class: "true"
driver: robin
deletionPolicy: Delete

Online-Sicherungs-Repository erstellen

Ein Online-Sicherungs-Repository ist ein S3-kompatibler Onlinespeicherort für Ihre VM-Sicherungen. Außerdem werden dort Aufzeichnungen von Sicherungen, Sicherungsplänen und Wiederherstellungsplänen gespeichert. Der Dienst dient auch als Ziel für die Wiederherstellung von VM-Sicherungen.

Führen Sie die folgenden Schritte aus, um ein Online-Sicherungs-Repository für Ihre virtuellen Maschinen zu erstellen:

  1. Erstellen Sie einen Cloud Storage-Bucket, wie unter Buckets erstellen beschrieben.

  2. Erstellen Sie mit den folgenden Befehlen ein Dienstkonto und einen Schlüssel für den Zugriff auf den Bucket:

    export PROJECT_ID=$(gcloud config get-value project)
export SVC_ACCOUNT=backup-access
gcloud iam service-accounts create $SVC_ACCOUNT
gcloud projects add-iam-policy-binding $PROJECT_ID \ 
   --member="serviceAccount:${SVC_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/backupdr.cloudStorageOperator"
gcloud storage hmac create  ${SVC_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com > hmac_temp_key_file
awk 'NR==1{print "ACCESS_ID=" $NF} NR==2{print "SECRET=" $NF}' < hmac_temp_key_file > hmac_key_file

  3. Konfigurieren Sie das Secret für den Zugriff auf den Sicherungs-Bucket mit den folgenden Befehlen:

    source ./hmac_key_file
kubectl create secret generic SECRET_NAME \
   --from-literal=access-key=$SECRET \
   --from-literal=access-key-id=$ACCESS_ID -n NAMESPACE

    Ersetzen Sie Folgendes:

    • SECRET_NAME: Ein aussagekräftiger Name für dieses Secret.
    • NAMESPACE: der Ziel-Namespace.

  4. Erstellen Sie die BackupRepository-Ressource und wenden Sie die folgende Konfiguration auf Ihren Cluster an:

    apiVersion: backup.gdc.goog/v1
kind: BackupRepository
metadata:
  name: "REPOSITORY_NAME"
spec:
  secretReference:
    namespace: NAMESPACE
    name: gcs-hmac-secret
  endpoint: "https://storage.googleapis.com"
  type: "S3"
  s3Options:
    bucket: "BUCKET_NAME"
    region: "REGION"
    forcePathStyle: true
  importPolicy: "ReadWrite"
# Force attachment for convenience.
force: true

    Ersetzen Sie Folgendes:

    • REPOSITORY_NAME: Ein aussagekräftiger Name für das Repository.
    • BUCKET_NAME: Der Name des Sicherungs-Buckets.
    • NAMESPACE: der Ziel-Namespace.
    • REGION: die Google Cloud Region, in der der Zielcluster für Distributed Cloud erstellt wurde.

  5. Prüfen Sie mit dem folgenden Befehl, ob der Cluster auf das Sicherungs-Repository zugreifen kann:

    kubectl get BackupRepository

Lokales Sicherungs-Repository erstellen

Ein lokales Sicherungs-Repository ist ein S3-kompatibler Speicherort für Ihre VM-Sicherungen, der sich lokal in Ihrem mit Distributed Cloud verbundenen Cluster befindet. Ein lokales Sicherungs-Repository ist funktional identisch mit einem Online-Sicherungs-Repository.

  1. Generieren Sie einen AES256-Verschlüsselungsschlüssel für die Verschlüsselung der Konfiguration auf Anwendungsebene:

    openssl rand -base64 32

    Der Befehl gibt einen zufälligen 256-Bit-Schlüssel aus, der base64-codiert ist. Beispiel:

    aBcD_eFgH1iJkLmN0pQrStUvWxFyZgAhIjKlMnOpQ=

  2. Doppelcodieren Sie den Schlüssel, der als Nutzlast in der YAML-Konfiguration für die BackupRepository-Ressource verwendet werden soll:

    echo -n "AES_KEY" | base64

    Ersetzen Sie AES_KEY durch den base64-codierten AES256-Schlüssel, den Sie im vorherigen Schritt generiert haben. Speichern Sie diesen Schlüssel in einer lokalen Datei.

  3. Konfigurieren Sie das Secret für den Zugriff auf das Sicherungs-Repository mit den folgenden Befehlen:

    kubectl create secret generic SECRET_NAME \
   --from-literal=access-key=ENCODED_AES_KEY \
   --namespace NAMESPACE

    Ersetzen Sie Folgendes:

    • ENCODED_AES_KEY: Der doppelt codierte AES256-Schlüssel, den Sie im vorherigen Schritt generiert haben.
    • SECRET_NAME: Ein aussagekräftiger Name für dieses Secret.
    • NAMESPACE: der Ziel-Namespace.

  4. Konfigurieren Sie BackupRepository, indem Sie die folgende Konfiguration auf Ihren Cluster anwenden:

    apiVersion: backup.gdc.goog/v1
kind: BackupRepository
metadata:
  name: REPOSITORY_NAME
spec:
  force: true
  importPolicy: ReadWrite
  localOptions:
    encryptionKey:
      name: SECRET_NAME
      namespace: NAMESPACE
  type: Local

  5. Prüfen Sie mit dem folgenden Befehl, ob der Cluster auf das Sicherungs-Repository zugreifen kann:

    kubectl get BackupRepository

    Ersetzen Sie Folgendes:

    • REPOSITORY_NAME: Ein aussagekräftiger Name für das Repository.
    • SECRET_NAME: der Name des Kubernetes-Secrets, das Sie im vorherigen Schritt erstellt haben.
    • NAMESPACE: der Namespace, in dem Sie das Kubernetes-Secret erstellt haben.

Sicherungsplan erstellen

Ein Sicherungsplan definiert den automatischen Zeitplan für die Ausführung der Sicherung Ihrer virtuellen Maschine. Erstellen Sie eine VirtualMachineBackupPlan-Ressource mit folgendem Inhalt und wenden Sie sie auf Ihren Cluster an:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupPlan
metadata:
  name: BACKUP_PLAN_NAME
  namespace: NAMESPACE
spec:
  backupConfig:
    backupRepository: REPOSITORY_NAME
    backupScope:
      selectedVirtualMachines:
      - resourceName: VM_NAME
    volumeStrategy: LocalSnapshotOnly
  backupSchedule:
    cronSchedule: "CRON_SCHEDULE"
    paused: PAUSED
  retentionPolicy:
    backupDeleteLockDays: PLAN_LOCK_LENGTH
    backupRetainDays: 4
    locked: RETENTION_POLICY_LOCKED
  numBackupsToRetain: BACKUPS_RETAINED

Ersetzen Sie Folgendes:

  • BACKUP_PLAN_NAME: ein aussagekräftiger Name für den Sicherungsplan.
  • NAMESPACE: der Name des Ziel-Namespace.
  • REPOSITORY_NAME: das Ziel-Sicherungs-Repository.
  • CRON_SCHEDULE: cron-Standardsicherungszeitplan. Das Mindestintervall zwischen Sicherungen beträgt 10 Minuten.
  • PAUSED: Gibt an, ob dieser Sicherungsplan pausiert ist. Gültige Werte sind true und false.
  • VM_NAME: Gibt eine VM-Arbeitslast an, die mit diesem Sicherungsplan gesichert werden soll. Sie können mehrere VM-Ressourcen pro Sicherungsplan angeben.
  • * BACKUP_LOCK_LENGTH: Gibt die Anzahl der Tage nach der Erstellung der Sicherung an, in denen die Sicherung nicht gelöscht werden kann.
  • * BACKUP_RETENTION_LENGTH: Gibt die Anzahl der Tage an, für die diese Sicherung beibehalten werden soll. Wenn die Aufbewahrungsdauer abläuft, wird die Sicherung gelöscht. Wenn keine Angabe gemacht wird, lautet der Standardwert 4.
  • * RETENTION_POLICY_LOCKED: Gibt an, ob die Aufbewahrungsrichtlinie dieses Sicherungsplans gesperrt ist. Gültige Werte sind true und false.
  • * BACKUPS_RETAINED/var>: Gibt die Anzahl der Sicherungen an, die in diesem Sicherungsplan beibehalten werden sollen. Wenn dieser Grenzwert erreicht ist, werden Sicherungen in der Reihenfolge vom ältesten zum neuesten gelöscht.

Vorhandene Sicherungspläne auflisten

Verwenden Sie den folgenden Befehl, um vorhandene Sicherungspläne aufzulisten:

kubectl get VirtualMachineBackupPlans -A

Die Ausgabe des Befehls sieht in etwa so aus:

NAMESPACE      NAME                                LASTBACKUPTIME   LASTBACKUPSTATE   NEXTBACKUPTIME   PAUSED
vm-workloads   bkp-template-vm-windows-vm-local
vm-workloads   sched-snapshotonly-bkp-plan-10min                                                       false

Manuelle Sicherung einer VM erstellen

Führen Sie die Schritte in diesem Abschnitt aus, um eine manuelle Sicherung einer VM zu erstellen.

  1. Erstellen Sie eine VirtualMachineBackupPlanTemplate-Ressource im Namespace, in dem sich die Ziel-VM befindet, indem Sie die folgende Konfiguration auf den Cluster anwenden:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupPlanTemplate
metadata:
  name: TEMPLATE_NAME
  namespace: NAMESPACE
spec:
  backupRepository: REPOSITORY_NAME

    Ersetzen Sie Folgendes:

    • TEMPLATE_NAME: Ein aussagekräftiger Name für diese Sicherungsvorlage.
    • REPOSITORY_NAME: Name des Ziel-Sicherungs-Repositorys.
    • NAMESPACE: der Ziel-Namespace.

  2. Lösen Sie die Sicherung aus, indem Sie eine VirtualMachineBackupRequest-Ressource mit der folgenden Konfiguration erstellen und auf den Cluster anwenden:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupRequest
metadata:
  name: BACKUP_REQUEST_NAME
  namespace: NAMESPACE
spec:
  vmBackupPlanTemplate: TEMPLATE_NAME
  virtualMachine: VM_NAME
  vmBackupName: BACKUP_NAME

    Ersetzen Sie Folgendes:

    • BACKUP_REQUEST_NAME: Ein aussagekräftiger Name für diese Sicherungsanfrage.
    • TEMPLATE_NAME: der Name der Sicherungsvorlage, die Sie im vorherigen Schritt erstellt haben.
    • NAMESPACE: der Name des Ziel-Namespace.
    • VM_NAME ist der Name der Ziel-VM.
    • BACKUP_NAME: Ein aussagekräftiger Name für diese Sicherung.

  3. Prüfen Sie die Integrität des Back-ups mit dem folgenden Befehl:

    kubectl get vmbackup BACKUP_NAME -n NAMESPACE

    Ersetzen Sie Folgendes:

    • BACKUP_NAME: der Name der Zielsicherung.
    • NAMESPACE: der Ziel-Namespace.

    Die Ausgabe des Befehls sieht in etwa so aus:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackup
metadata:
  creationTimestamp: "2024-04-09T17:57:44Z"
  finalizers:
  - vm.cluster.gke.io/virtual-machine-backup-finalizer
  generation: 1
  name: vmt13-backup-0409-2
  namespace: default
  ownerReferences:
  - apiVersion: backup.gdc.goog/v1
    kind: Backup
    name: vmt13-backup-0409-2
    uid: 0ee0b92c-1e27-48cc-8f8f-5606ea925e88
  resourceVersion: "36192759"
  uid: e471f8c7-637c-485f-acda-108017a5638f
spec:
  backupConfig:
    backupRepository: default
    backupScope:
      selectedVirtualMachines:
      - resourceName: vm-t13
    volumeStrategy: Portable
  vmBackupPlan: MyVmPlan-vm-vm-t13-portable
status:
  backedUpVirtualMachineDisks:
  - vm-t13-boot-disk
  - vm-t13-data-disk
  backedUpVirtualMachines:
  - vm-t13
  backup: vmt13-backup-0409-2
  backupStatus:
    clusterMetadata:
      k8sVersion: "1.28"
    completeTime: "2024-04-09T18:07:36Z"
    createTime: "2024-04-09T17:57:44Z"
    jobCreated: true
    resourceCount: 849
    sizeBytes: 1948672
    state: Succeeded

VM-Sicherungen auflisten

Verwenden Sie den folgenden Befehl, um vorhandene Sicherungen virtueller Maschinen aufzurufen:

kubectl get VirtualMachineBackups -A

Die Ausgabe des Befehls sieht in etwa so aus:

NAMESPACE      NAME        STATE       CREATETIME
vm-workloads   vm-backup   Succeeded   2025-04-08T04:37:32Z

Virtuelle Maschine aus einer Sicherung wiederherstellen

Führen Sie die Schritte in diesem Abschnitt aus, um eine VM aus einer Sicherung wiederherzustellen.

  1. Lösen Sie den Wiederherstellungsvorgang aus, indem Sie eine VirtualMachineRestoreRequest-Ressource mit der folgenden Konfiguration erstellen und auf Ihren Cluster anwenden:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineRestoreRequest
metadata:
  name: restore-req
  namespace: NAMESPACE
spec:
  vmBackup: BACKUP_NAME
  restoreName: RESTORE_NAME
  restoredResourceName: RESTORED_VM_NAME
  restoredResourceDescription: RESTORE_DESCRIPTION

    Ersetzen Sie Folgendes:

    • BACKUP_NAME: der Name der Zielsicherung.
    • RESTORE_NAME: Ein aussagekräftiger Name für diesen Wiederherstellungsvorgang.
    • NAMESPACE: der Ziel-Namespace.
    • RESTORED_VM_NAME: Der Name, der der VM bei der Wiederherstellung gegeben wurde. Dieser Name darf nicht mit Namen von virtuellen Maschinen in Konflikt stehen, die bereits im Cluster vorhanden sind.
    • RESTORE_DESCRIPTION: Eine Beschreibung für diesen Wiederherstellungsvorgang.

  2. Verwenden Sie den folgenden Befehl, um den Fortschritt des Wiederherstellungsvorgangs zu prüfen:

    kubectl get virtualmachinerestores.vm.cluster.gke.io RESTORE_NAME -n NAMESPACE

    Ersetzen Sie Folgendes:

    • RESTORE_NAME: der Name des Zielwiederherstellungsvorgangs.
    • NAMESPACE: der Ziel-Namespace.

    Die Ausgabe des Befehls sieht in etwa so aus:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineRestore
metadata:
  creationTimestamp: "2024-04-09T18:09:51Z"
  finalizers:
  - vm.cluster.gke.io/virtual-machine-restore-finalizer
  generation: 1
  name: vmt13-restore-0409-2-1
  namespace: default
  ownerReferences:
  - apiVersion: backup.gdc.goog/v1
    kind: Restore
    name: vmt13-restore-0409-2-1
    uid: 4ce1ca83-eba0-4cc3-bad3-af6cf9185d7d
  resourceVersion: "36194596"
  uid: aba50b59-e18d-4687-ad11-47baa45478b4
spec:
  targetVirtualMachineDisks:
  - vm-t13-boot-disk
  - vm-t13-data-disk
  targetVirtualMachines:
  - vm-t13
  vmBackup: vmt13-backup-0409-2
status:
  restore: vmt13-restore-0409-2-1
  restoreStatus:
    completeTime: "2024-04-09T18:10:00Z"
    jobCreated: true
    resourcesRestoredCount: 5
    restoredVolumesCount: 2
    startTime: "2024-04-09T18:09:51Z"
    state: Succeeded
    stateReason: restore is successful

Wiederherstellungsvorgänge ansehen

Verwenden Sie den folgenden Befehl, um die bisher initiierten Wiederherstellungsvorgänge aufzurufen:

kubectl get VirtualMachineRestore.vm.cluster.gke.io -A

Die Ausgabe des Befehls sieht in etwa so aus:

NAMESPACE      NAME        STARTTIME              RESTORE     STATE
vm-workloads   restore-1   2025-04-08T04:41:04Z   restore-1   Succeeded

VM-Sicherung löschen

Wenn Sie ein VM-Backup löschen möchten, erstellen Sie eine VirtualMachineDeleteBackupRequest-Ressource mit der folgenden Konfiguration und wenden Sie sie auf Ihren Cluster an:

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachineDeleteBackupRequest
    metadata:
      name: vmdbr
      namespace: BACKUP_NAME
    spec:
      vmBackup: NAMESPACE

Ersetzen Sie Folgendes:

  • NAMESPACE: der Name des Ziel-Namespace.
  • BACKUP_NAME: der Name der Zielsicherung.

Audit-Logs für AppArmor-Sandbox ansehen

Distributed Cloud Connected führt automatisch Sandboxing für VM-Arbeitslasten mit AppArmor-Richtlinien in audit-mode durch. Bei einem Richtlinienverstoß wird ein Audit-Log-Eintrag ausgegeben. Beispiel:

{
  "jsonPayload": {
    "_SOURCE_REALTIME_TIMESTAMP": "1734596844149104",
    "SYSLOG_TIMESTAMP": "Dec 19 08:27:24 ",
    "MESSAGE": "type=AVC msg=audit(1734596844.148:27742): apparmor=\"ALLOWED\" operation=\"open\" profile=\"virt-launcher-audit\" name=\"/etc/libvirt/virtlogd.conf\" pid=182406 comm=\"virtlogd\" requested_mask=\"r\" denied_mask=\"r\" fsuid=0 ouid=0 FSUID=\"root\" OUID=\"root\"",
    "PRIORITY": "6",
    ...
    "SYSLOG_RAW": "<14>Dec 19 08:27:24 audisp-syslog: type=AVC msg=audit(1734596844.148:27742): apparmor=\"ALLOWED\" operation=\"open\" profile=\"virt-launcher-audit\" name=\"/etc/libvirt/virtlogd.conf\" pid=182406 comm=\"virtlogd\" requested_mask=\"r\" denied_mask=\"r\" fsuid=0 ouid=0 FSUID=\"root\" OUID=\"root\"\n",
    "SYSLOG_IDENTIFIER": "audisp-syslog",
    "_GID": "0",
  },
  "timestamp": "2024-12-19T08:27:24.149109Z",
  "labels": {
    "gke.googleapis.com/log_type": "system"
  },
  "receiveTimestamp": "2024-12-19T08:27:24.721842807Z"
  ...
  ...
}

Nächste Schritte