Virtuelle Maschinen verwalten

Auf dieser Seite wird beschrieben, wie Sie virtuelle Maschinen in Ihrer Google Distributed Cloud Connected-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 Distributed Cloud-Plattform dienen, finden Sie unter GKE Enterprise erweitern, um Edge-VMs vor Ort zu verwalten.

Distributed Cloud Connected-Cluster 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 als Abstraktionsebene für den lokalen Speicher auf jedem mit Distributed Cloud verbundenen Knoten fungiert und den lokalen Speicher für Arbeitslasten verfügbar macht, die auf anderen mit Distributed Cloud verbundenen 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 Google Distributed Cloud Connected-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 -f LICENSE_FILE

    Ersetzen Sie LICENSE_FILE durch den Pfad zur Lizenzdatei.

  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 Speicherklasse 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 die storageprofile für die Speicherklasse robin-block-immediate mit dem folgenden Inhalt und wenden Sie sie 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=v1.3.1-anthos1.35-gke.39
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 -

  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 einem Kubernetes-Dienstkonto direkten Zugriff auf den Bucket zu gewähren. Wenn Sie bereits ein etabliertes Bild-Repository haben, können Sie diesen Abschnitt überspringen.

Um das Risiko der Identitätsgleichheit in einer Multi-Cluster-Flotte zu verringern, folgen Sie den Richtlinien unter Best Practices für die Workload Identity-Föderation der Flotte, wenn Sie die Schritte in diesem Abschnitt ausführen.

  1. Folgen Sie der Anleitung unter Buckets erstellen, um einen Bucket zu erstellen.

  2. Erstellen Sie ein Kubernetes-Dienstkonto im Namespace der Ziel-VM:

    export VM_NAMESPACE=NAMESPACE
export KUBERNETES_SERVICEACCOUNT=KUBERNETES_SERVICEACCOUNT
kubectl create serviceaccount ${KUBERNETES_SERVICEACCOUNT} -n ${VM_NAMESPACE}

    Ersetzen Sie Folgendes:

    • NAMESPACE: Der Namespace der Ziel-VM.
    • KUBERNETES_SERVICEACCOUNT: Ein aussagekräftiger Name für dieses Kubernetes-ServiceAccount.

  3. 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 Flotten-Hostprojekts Google Cloud .

    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:

  4. Weisen Sie dem Kubernetes-Dienstkonto die Rolle „Storage Object Viewer“ (roles/storage.objectViewer) für den Bucket zu:

    export BUCKET_PROJECT_ID=BUCKET_PROJECT_ID
export FLEET_PROJECT_NUMBER=FLEET_PROJECT_NUMBER
export KUBERNETES_SERVICEACCOUNT=KUBERNETES_SERVICEACCOUNT
export VM_NAMESPACE=NAMESPACE
export WI_POOL=WORKLOAD_IDENTITY_POOL
gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
   --member="principal://iam.googleapis.com/projects/${FLEET_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${WI_POOL}/subject/ns/${VM_NAMESPACE}/sa/${KUBERNETES_SERVICEACCOUNT}" \
   --role="roles/storage.objectViewer" \
   --project=${BUCKET_PROJECT_ID} \
   --condition="IAM_CONDITION" \
   --condition-from-file="IAM_CONDITION_FILE"

    Ersetzen Sie Folgendes:

    • BUCKET_PROJECT_ID: Die ID des Google Cloud -Projekts, in dem sich der Bucket befindet.
    • FLEET_PROJECT_NUMBER: Die Projektnummer des Flotten-Hostprojekts Google Cloud .
    • KUBERNETES_SERVICEACCOUNT: der Name des Ziel-Kubernetes-ServiceAccount.
    • 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 das Feld weggelassen oder auf None gesetzt wird, gelten keine IAM-Bedingungen.
    • IAM_CONDITION_FILE: optional; gibt die Datei mit den IAM-Bedingungen an, mit denen der Zugriff auf bestimmte Cluster in der Flotte eingeschränkt werden soll. Wenn es weggelassen wird, gelten keine IAM-Bedingungen, es sei denn, das Flag --condition ist angegeben und auf einen anderen Wert als None gesetzt.

  5. 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 der 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-Bedingungen einrichten und anwenden, um den Zugriff auf Ihren Bucket einzuschränken:

  1. IAM-Bedingungsdatei erstellen:

    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 dem Kubernetes-ServiceAccount Zugriff auf den Bucket gewähren:

    gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
  --project="${BUCKET_PROJECT_ID}" \
  --role="roles/storage.objectViewer" \
  --member="principal://iam.googleapis.com/projects/${FLEET_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${WI_POOL}/subject/ns/${VM_NAMESPACE}/sa/${KUBERNETES_SERVICEACCOUNT}" \
  --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: KUBERNETES_SERVICEACCOUNT
   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 -Konsole und wählen Sie gsutil-URI kopieren aus, um diesen Pfad zu erhalten.
  • KUBERNETES_SERVICEACCOUNT: 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 ermitteln.

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 Secret.

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

Leeres Laufwerk erstellen

Erstellen Sie eine leere VM-Festplatte, 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 Laufwerksgröß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 ermitteln.

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 Netzwerk, 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 virtuelle Maschine auf Ihrer Distributed Cloud-Serverbereitstellung 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.

Die Ressourcenzuweisung für VMs ist durch die Hardwareprofile Ihrer mit Distributed Cloud verbundenen Bereitstellung eingeschränkt, z. B. G1- oder G2-Hardware. Sie können eine einzelne VM nicht größer als die physische Distributed Cloud-Maschine machen, auf der sie ausgeführt wird.

Mit der Google Cloud Console eine virtuelle Maschine 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 Pop-up-Dialogfeld die gewünschte 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 VM verwenden möchten, wählen Sie Standardkonfiguration aus, wählen Sie in der Drop-down-Liste Maschinentyp eine Maschinenkonfiguration aus und 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 werden soll, wenn diese VM gelöscht wird.

    • Geben Sie in der Drop-down-Liste Treiber einen Treiber für das virtuelle Laufwerk 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 Netzwerktyp den entsprechenden Netzwerktyp aus.

    3. Geben Sie mit dem Kästchen Externen Zugriff zulassen 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 extern freizugebenden Ports eingeben.

    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 VM 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 die UEFI-Firmware auswählen, können Sie Secure Boot über das 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. Geben Sie im Abschnitt Cloud-init im Feld User data secret einen Secret-Wert für Nutzerdaten an.

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

VM 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 Pop-up-Dialogfeld die gewünschte 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. Weitere Informationen zu den unterstützten YAML-Feldern finden Sie in der Referenz zur Spezifikation virtueller Maschinen.

  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. Informationen zum Anpassen dieser Konfiguration, z. B. der CPU-, Arbeitsspeicher- oder Netzwerkoptionen, finden Sie in der Referenz zur Spezifikation virtueller Maschinen:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: my-virtual-machine
  namespace: NAMESPACE
spec:
  osType: Linux/Windows
  # guestEnvironment: {} # uncomment this line to disable guest environment
  priorityClassName: PRIORITY_CLASS
  compute:
    cpu:
      vcpus: 6
    memory:
      capacity: 8Gi
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      ipAddresses:
        - IP_ADDRESS/PREFIX
  disks:
    - virtualMachineDiskName: DISK_NAME
      boot: true
    - virtualMachineDiskName: DISK_NAME

Ersetzen Sie Folgendes:

  • NAMESPACE: der Ziel-Namespace.
  • PRIORITY_CLASS: Die Prioritätsklasse für diese VM. Eine Prioritätsklasse ist ein Bereich von Prioritätswerten. Eine Liste der unterstützten Prioritätsklassen finden Sie unter kubectl get priorityclass. Eine höhere Planungspriorität verringert die Wahrscheinlichkeit, dass VMs entfernt werden, wenn die Knotenressourcen begrenzt sind. Wenn er weggelassen wird, erhält die virtuelle Maschine den niedrigsten Standardprioritätswert.
  • NETWORK_NAME: Der Name des L2-Netzwerks, an das die VM-Schnittstelle angehängt werden soll.
  • DISK_NAME: die Namen der Laufwerke dieser VM.
  • vcpus: die Anzahl der vCPUs, die der VM zugewiesen werden sollen.
  • capacity: die Menge an Arbeitsspeicher, die der VM zugewiesen werden soll. Beispiel: 4Gi oder 8Gi.
  • ipAddresses: optional; ermöglicht die Zuweisung einer statischen IP-Adresse für die VM. Wenn das zugrunde liegende L2-Netzwerk externes DHCP unterstützt, können Sie ipAddresses weglassen, um eine dynamische Zuweisung zu ermöglichen.

cloud-init-API zum Initialisieren von VMs verwenden

Die cloud-init API ist eine Standardmethode zum Initialisieren einer Cloud-VM. Verwenden Sie cloud-init, um Dateien, Nutzer und andere Aspekte Ihrer VM einzurichten.

Prüfen Sie die Startroutinen von cloud-init, um die Kompatibilität sicherzustellen. Bevor Sie die Konfiguration in der Produktion verwenden, wenden Sie sie auf eine Test-VM an, um sicherzustellen, dass sie erfolgreich initialisiert wird.

Die folgenden Beispiele sind allgemein und müssen in Ihrer Umgebung getestet werden.

VM-Konfiguration mit cloud-init-Nutzerdaten automatisieren

VM Runtime on GDC unterstützt cloud-init-Nutzerdaten für Linux-VMs. Sie können Nutzerdaten als Klartextstring, als base64-codierten String oder durch Verweisen auf ein Kubernetes-Secret angeben.

Damit Ihre VM richtig initialisiert wird, sollten Sie alle Konfigurationen für Nutzerdaten validieren, bevor Sie sie in einer Produktionsumgebung bereitstellen.

Das folgende Beispiel zeigt ein VirtualMachine-Manifest, das cloud-init-Nutzerdaten im Nur-Text-Format enthält, um einen Befehl beim Starten der VM auszuführen:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  osType: Linux
  cloudInit:
    noCloud:
      userData: |
        #cloud-config
        runcmd:
          - echo "Hello World" > /tmp/hello.txt

Ersetzen Sie VM_NAME durch den Namen der VM.

Wenn Sie die VM mit cloud-init-Daten erstellen möchten, speichern Sie das Manifest als vm-cloud-init.yaml und wenden Sie es auf Ihren Cluster an, indem Sie den Befehl kubectl apply ausführen:

kubectl apply -f vm-cloud-init.yaml

Fehlerbehebung für cloud-init

Wenn Sie Probleme mit cloud-init haben, prüfen Sie die Logs in der VM. Die Logs finden Sie in der Regel in den folgenden Verzeichnissen:

  • /var/log/cloud-init.log
  • /var/log/cloud-init-output.log

VM aus einem ISO-Image einer optischen Disc erstellen

Sie können eine Windows-VM erstellen, die mit VM Runtime on GDC von einem ISO-Image bootet. Mit dieser Funktion können Sie Legacy-Unternehmensanwendungen auf Windows-Basis, spezielle Drittanbieter-Software oder benutzerdefinierte Point-of-Sale-Systeme direkt zu Ihren mit Distributed Cloud verbundenen Clustern migrieren.

Für VM-Laufwerke verwendete Images werden aus einem mit Distributed Cloud verbundenen Image-Bucket importiert. Bevor Sie die Manifeste erstellen, müssen Sie das Windows-Installations-ISO und das KubeVirt-ISO mit virtio-Treibern herunterladen und in Ihren Image-Bucket hochladen. Wir empfehlen, eine bestätigte Kopie der Treiber-ISO in einem internen Repository zu speichern oder in Cloud Storage vorzubereiten, um zuverlässige, wiederholbare VM-Builds zu gewährleisten.

Manifeste erstellen

Wenn Sie von einem Windows-ISO-Image booten möchten, benötigen Sie die folgenden Manifeste:

  • Eine VirtualMachineDisk mit der Windows-ISO.
  • Ein VirtualMachineDisk mit den KubeVirt Windows-Treibern virtio.
  • Ein leeres VirtualMachineDisk, das als Bootlaufwerk dienen soll, auf dem Windows installiert wird.

Die folgenden Beispiele zeigen die VirtualMachineDisk-Manifeste für die drei erforderlichen Datenträger.

Ersetzen Sie in den Manifesten Folgendes:

  • BUCKET_PROJECT_ID: Die Projekt-ID, in der sich Ihr Bild-Bucket befindet.
  • KUBERNETES_SERVICEACCOUNT: Das Kubernetes-ServiceAccount mit Berechtigungen zum Lesen aus dem Bucket.

Die in den Manifesten angeforderte PVC-Größe size muss immer größer oder gleich der genauen virtuellen Größe der ISO sein.

Windows-ISO-Datenträger

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-iso
spec:
  size: 10Gi
  storageClassName: robin-block-immediate
  diskType: cdrom
  source:
    gcs:
      url: gs://BUCKET_PROJECT_ID-vm-images/windows.iso
      serviceAccount: KUBERNETES_SERVICEACCOUNT

VirtIO-Treiber-Disk

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: virtio-driver
spec:
  size: 1Gi
  storageClassName: robin-block-immediate
  diskType: cdrom
  source:
    gcs:
      url: gs://BUCKET_PROJECT_ID-vm-images/virtio-win.iso
      serviceAccount: KUBERNETES_SERVICEACCOUNT

Leeres Bootlaufwerk

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-vm-boot-dv
spec:
  size: 40Gi
  storageClassName: robin-block-immediate

Laufwerke erstellen

Speichern Sie die VirtualMachineDisk-Manifeste und wenden Sie sie auf Ihren Cluster an, indem Sie den Befehl kubectl apply ausführen, um diese Laufwerke zu erstellen:

kubectl apply -f windows-iso.yaml
kubectl apply -f virtio-driver.yaml
kubectl apply -f windows-vm-boot-dv.yaml

Erstellen Sie eine Windows-VM:

Wenn Sie eine Windows-VM erstellen möchten, erstellen Sie ein Manifest, das die VM definiert und auf die Laufwerke verweist. Die VM wird vom ISO-Laufwerk gestartet, um die Installation zu starten.

Das folgende Beispiel zeigt ein VirtualMachine-Manifest:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  labels:
    kubevirt.io/vm: windows-vm
  name: windows-vm
spec:
  osType: Windows
  disks:
    - virtualMachineDiskName: windows-vm-boot-dv
      boot: true
    - virtualMachineDiskName: windows-iso
    - virtualMachineDiskName: virtio-driver
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
      ipAddresses:
        - IP_ADDRESS/PREFIX

Speichern Sie das Manifest als windows-vm.yaml und wenden Sie es auf Ihren Cluster an, indem Sie den Befehl kubectl apply ausführen, um die VM zu erstellen:

kubectl apply -f windows-vm.yaml

Verbinden und Installation abschließen

So stellen Sie eine Verbindung her und schließen die Installation ab:

  1. So stellen Sie mit VNC eine Verbindung zur VM her: Verwenden Sie das Tool virtctl oder das Plug-in kubectl virt:

    virtctl vnc windows-vm

    Oder, wenn Sie virtctl als kubectl-Plug-in installiert haben:

    kubectl virt vnc windows-vm

    Weitere Informationen zu virtctl finden Sie in der KubeVirt-Dokumentation.

  2. Folgen Sie der Anleitung des Windows-Installationsprogramms. Wählen Sie bei entsprechender Aufforderung Benutzerdefinierte Installation aus.

  3. Laden Sie bei Aufforderung die virtio-Treiber für Speicher und Netzwerk, indem Sie auf die angehängte virtio-driver-Festplatte zugreifen.

  4. Schließen Sie die Installation ab.

Zugriff über Remote Desktop Protocol

Nachdem Sie RDP (Remote Desktop Protocol) im Gastbetriebssystem installiert und aktiviert haben, können Sie über RDP auf die VM zugreifen.

Da die VM an ein L2-Netzwerk angehängt ist, ist sie über ihre zugewiesene IP-Adresse (z. B. 10.223.237.10) direkt von außerhalb des Clusters erreichbar. Stellen Sie über einen RDP-Client eine Verbindung zu dieser IP-Adresse auf Port 3389 her. Achten Sie darauf, dass die interne L2-IP-Adresse über Ihre Unternehmensfirewall und Routingregeln von Ihrem Clientcomputer aus erreichbar ist.

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.

Referenz zu Spezifikationen virtueller Maschinen

In der folgenden Tabelle werden die wichtigsten Felder in der VirtualMachine-Spezifikation beschrieben. Verwenden Sie diese Felder, wenn Sie ein YAML-Manifest für eine virtuelle Maschine konfigurieren, das mit kubectl apply auf Ihren Cluster angewendet werden soll, oder wenn Sie die Option Mit YAML erstellen in der Google Cloud -Konsole verwenden.

Feld Beschreibung Erforderlich
apiVersion Muss vm.cluster.gke.io/v1 lauten. Erforderlich
kind Muss VirtualMachine lauten. Erforderlich
metadata.name Ein eindeutiger Name für die virtuelle Maschine. Erforderlich
metadata.namespace Der Kubernetes-Namespace, in dem die VM ausgeführt wird. Erforderlich
spec.osType Der Typ des Gastbetriebssystems. Unterstützte Werte: Linux und Windows. Erforderlich
spec.guestEnvironment Konfiguriert die Gastumgebung. Wenn keine Angabe gemacht wird, ist die Gastumgebung standardmäßig aktiviert. Setzen Sie den Wert auf {}, um sie zu deaktivieren. Optional
spec.priorityClassName Die Prioritätsklasse für die VM. Eine höhere Priorität verringert die Wahrscheinlichkeit, dass die Instanz entfernt wird. Optional
spec.compute Konfiguriert die Rechenressourcen für die VM. Erforderlich
spec.compute.cpu.vcpus Anzahl der zuzuweisenden vCPUs. Zulässige Werte sind 1 bis 96. Erforderlich
spec.compute.memory.capacity Arbeitsspeicherkapazität, z. B. 8Gi. Erforderlich
spec.interfaces Liste der Netzwerkschnittstellen für die VM. Erforderlich
spec.interfaces[].name Name der Schnittstelle, z. B. eth0. Erforderlich
spec.interfaces[].networkName Name des Subnetzwerks, mit dem eine Verbindung hergestellt werden soll. Dies entspricht einer Network-Ressource im Cluster. Erforderlich
spec.interfaces[].ipAddresses Statische IP-Adressen, die dieser Schnittstelle zugewiesen werden sollen. Wenn für das Subnetz kein DHCP aktiviert ist, müssen Sie eine statische IP-Adresse angeben. Optional
spec.disks Liste der Laufwerke, die an die VM angehängt werden sollen. Erforderlich
spec.disks[].virtualMachineDiskName Name der VirtualMachineDisk-Ressource. Erforderlich
spec.disks[].boot Legen Sie für das Bootlaufwerk true fest. Nur ein Laufwerk kann als bootfähig markiert werden. Optional

Auf eine virtuelle Maschine zugreifen

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

Netzwerkanforderungen für den Direktzugriff

Wenn Sie direkt von Ihrem lokalen Netzwerk aus auf eine VM zugreifen möchten, ohne einen Kubernetes-LoadBalancer-Dienst zu verwenden, müssen Sie die logischen und physischen Netzwerkkomponenten konfigurieren. Distributed Cloud Connected verwaltet automatisch die Netzwerkressourcen im Cluster. Sie müssen jedoch das externe Netzwerk und die VM-Schnittstelle konfigurieren.

  1. Subnetzwerk (VLAN) konfigurieren: Erstellen Sie ein Subnetzwerk mit einer bestimmten VLAN-ID über die Distributed Cloud Edge Network API mit gcloud oder der API. Distributed Cloud Connected synchronisiert diese Konfiguration automatisch mit Ihrem Cluster. Sie müssen keine Kubernetes-Netzwerkressourcen manuell erstellen. Weitere Informationen finden Sie unter Subnetzwerke erstellen und verwalten.

  2. Lokales Netzwerk konfigurieren: Ihr Netzwerkadministrator muss die physischen Switches und Router, die mit den mit Distributed Cloud verbundenen Servern verbunden sind, so konfigurieren, dass:

    • Lassen Sie die konfigurierte VLAN-ID an den Switch-Ports zu (VLAN-Trunking).
    • Aktivieren Sie das Routing zwischen Ihrem lokalen Netzwerk und dem Subnetzwerk. Wenn Border Gateway Protocol (BGP), ein dynamisches Routingprotokoll, auf Ihren mit Distributed Cloud verbundenen Routern konfiguriert ist, werden diese Routen automatisch beworben, nachdem das Subnetzwerk erstellt wurde. Andernfalls müssen Sie statische Routen auf Ihren physischen Routern konfigurieren, um den Traffic für den IP-Bereich (CIDR) des Subnetzwerks an die mit Distributed Cloud verbundenen Knoten weiterzuleiten.

  3. VM-Schnittstelle konfigurieren: Konfigurieren Sie in Ihrer VirtualMachine-YAML-Konfiguration die VM so, dass sie dieses Subnetzwerk verwendet. Geben Sie dazu den Netzwerknamen im Feld spec.interfaces an. Weitere Informationen finden Sie in der Referenz zu Spezifikationen für virtuelle Maschinen.

Zugriffsanmeldedaten für Linux-VMs abrufen

Wenn Sie noch keine Anmeldedaten für den Zugriff auf die VM 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 mit einem SSH-Schlüsselpaar:

    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 aussagekräftiger Name für diese Ressource der VM-Zugriffsanfrage.
    • NAMESPACE: der Ziel-Namespace.
    • VM_NAME: 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.

  4. Führen Sie den Befehl kubectl get aus, um den Status der Zugriffsanfrage zu prüfen:

    kubectl get vmar

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

  5. Greifen Sie über SSH auf die virtuelle Maschine zu. Wenn die virtuelle Maschine mit Ihrem lokalen Netzwerk verbunden ist, greifen Sie direkt über SSH darauf zu:

    ssh USERNAME@VM_IP_ADDRESS -i PATH_TO_KEY

    Ersetzen Sie Folgendes:

    • USERNAME: Der Nutzername für die Anmeldung, z. B. der in der Ressource VirtualMachineAccessRequest konfigurierte Nutzer.
    • VM_IP_ADDRESS: die IP-Adresse Ihrer VM.
    • PATH_TO_KEY: Der Pfad zum privaten SSH-Schlüssel, der dem in den vorherigen Schritten generierten öffentlichen Schlüssel entspricht.

Über RDP auf eine Windows-VM zugreifen

Wenn Sie über Ihr lokales Netzwerk mit Remote Desktop Protocol (RDP) auf eine Windows-VM zugreifen möchten, müssen Sie RDP im Gastbetriebssystem aktivieren, dafür sorgen, dass die VM über das Netzwerk erreichbar ist, und Nutzeranmeldedaten einrichten.

Vorbereitung

RDP in Windows aktivieren: RDP muss im Windows-Gastbetriebssystem aktiviert sein. Wenn RDP noch nicht aktiviert ist, verwenden Sie eine VNC-Konsole (Virtual Network Computing), um direkt auf den VM-Bildschirm zuzugreifen und RDP zu aktivieren. Mit dem Befehl kubectl virt vnc wird ein grafisches Ansichtsfenster auf Ihrer lokalen Workstation geöffnet. Dazu muss ein VNC-Viewer-Client wie Remote Viewer oder VNC Viewer auf Ihrer Workstation installiert sein:

kubectl virt vnc VM_NAME -n NAMESPACE

Ersetzen Sie Folgendes:

  • VM_NAME: der Name Ihrer Windows-VM.
  • NAMESPACE: der Namespace der VM.

Verbindung über RDP herstellen

  1. Führen Sie den Befehl kubectl get aus, um die IP-Adresse der VM abzurufen:

    kubectl get vmi VM_NAME -n NAMESPACE -o jsonpath='{.status.interfaces[*].ipAddress}'

    Ersetzen Sie Folgendes:

    • VM_NAME: der Name Ihrer Windows-VM.
    • NAMESPACE: der Namespace der VM.

    Notieren Sie sich die IP-Adresse, die zu Ihrem gerouteten Subnetzwerk gehört.

  2. Verwenden Sie einen Standard-RDP-Client wie die Remotedesktopverbindung unter Windows oder Remmina unter Linux, um eine Verbindung zur abgerufenen IP-Adresse auf Port 3389 herzustellen.

  3. Melden Sie sich mit dem Nutzernamen und dem Passwort an.

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: Der Name der Ziel-VM.
  • NAMESPACE: der Ziel-Namespace.

Virtuelle Maschine mit der 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 die gewünschte 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 STARTEN oder BEENDEN.

Status einer virtuellen Maschine in der Google Cloud Console ansehen

  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 Pop-up-Dialogfeld die gewünschte 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 VM 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 die gewünschte 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 das Kästchen für die Ziel-VM aus.

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

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

Nächste Schritte