Virtuelle Maschinen auf Distributed Cloud Connect-Servern verwalten

Auf dieser Seite wird beschrieben, wie Sie virtuelle Maschinen auf Google Distributed Cloud-Servern verwalten, auf denen 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-Server verwenden 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:

  1. Erstellen Sie den Namespace robinio mit dem folgenden Befehl:

    kubectl create ns robinio

  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 apply LICENSE_FILE

    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

VM Runtime on GDC-Unterstützung in Distributed Cloud Connect aktivieren

Standardmäßig ist die Unterstützung für virtuelle Maschinen in VM Runtime on GDC für Distributed Cloud Connected deaktiviert. Führen Sie die Schritte in diesem Abschnitt aus, um die Funktion zu aktivieren. Bei der Anleitung in diesem Abschnitt wird davon ausgegangen, dass Sie einen voll funktionsfähigen Distributed Cloud Connect-Cluster haben.

Führen Sie die folgenden Schritte aus, um die VM Runtime im GDC-Subsystem für virtuelle Maschinen zu aktivieren:

  1. Ändern Sie die benutzerdefinierte Ressource VMRuntime mit dem folgenden Inhalt und wenden Sie sie auf Ihren Cluster an:

    apiVersion: vm.cluster.gke.io/v1
kind: VMRuntime
metadata:
  annotations:
    baremetal.cluster.gke.io/vmrumtime-force-disable: "false"
    vm.cluster.gke.io/enable-vm-backup: "true"
spec:
  enabled: true
  storage:
    defaultStorageClass: robin-block-immediate
haPolicy:
  defaultRecoveryStrategy: Reschedule
  nodeHeartbeatInterval: 15s
  nodeMonitorGracePeriod: 55s

    Dieser Vorgang dauert in der Regel einige Minuten.

  2. Verwenden Sie den folgenden Befehl, um zu prüfen, ob die benutzerdefinierte Ressource VMRuntime auf Ihren Cluster angewendet wurde:

    kubectl get vmruntime

    Der Befehl gibt eine Ausgabe ähnlich dem folgenden Beispiel zurück:

    NAME        AGE   ENABLED   READY   PREFLIGHTCHECK
vmruntime   5m   true      true    true

  3. Ä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=v0.59.0-anthos1.28-gke.8
gcloud storage cp gs://anthos-baremetal-release/virtctl/${VERSION}/linux-amd64/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. Wenn Sie bereits ein Image-Repository haben, überspringen Sie diesen Abschnitt.

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

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

    export PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts create image-access
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:image-access@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/storage.objectViewer" \
gcloud iam service-accounts keys create ./image-access-gcr.json \
  --iam-account="image-access@${PROJECT_ID}.iam.gserviceaccount.com"

  3. Erstellen Sie ein Secret im Cluster, um auf den Bucket zuzugreifen. Wenn Ihr Bucket öffentlich ist, überspringen Sie diesen Schritt. Dieses Secret muss im selben Namespace wie Ihre VM-Laufwerke vorhanden sein. Sie müssen in jedem betroffenen Namespace ein Secret erstellen.

    kubectl create secret generic gcs-image-sa --from-file=creds-gcp.json=./image-access-gcr.json -n NAMESPACE

    Ersetzen Sie CLUSTER_ID durch den Namen des Ziel-Namespace.

  4. Speichern Sie Ihre Bilder im Bucket.

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://{PROJECT_ID}-vm-images/IMAGE_FILE
       secretRef: gcs-image-sa
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Ersetzen Sie Folgendes:

  • DISK_NAME: der Name dieses VM-Laufwerks.
  • NAMESPACE: der Ziel-Namespace.
  • IMAGE_FILE ist der Name der VM-Imagedatei.
  • DISK_SIZE: Die gewünschte Laufwerkgröße. 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 vorhandenen Laufwerk-Image erstellen

Erstellen Sie eine VM-Festplatte aus einer vorhandenen VM-Festplatte oder Image-Datei in Ihrem Cluster.

  1. Erstellen Sie das Ziellaufwerk, indem Sie die folgende Konfiguration auf Ihren Cluster anwenden:

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

    Ersetzen Sie Folgendes:

    • IMAGE_DISK_NAME: der Name dieses VM-Laufwerks.
    • NAMESPACE: der Ziel-Namespace.
    • EXISTING_DISK_NAME: der Name des vorhandenen VM-Laufwerks.
    • DISK_SIZE: Die gewünschte Laufwerkgröße. Diese muss größer oder gleich der Größe des vorhandenen Laufwerks oder der vorhandenen Bilddatei sein.

    Sie können die Größe Ihres vorhandenen Laufwerks oder Ihrer vorhandenen Image-Datei mit dem Tool qemu-img so ermitteln:

    qemu-img info EXISTING_DISK_NAME

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

  2. Erstellen Sie einen neuen Datenträger aus Ihrer vorhandenen Imagedatei, 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:
    virtualMachineDisk:
      name: IMAGE_DISK_NAME
  size: DISK_SIZE
  storageClassName: robin-block-immediate

    Ersetzen Sie Folgendes:

    • IMAGE_DISK_NAME: der Name des VM-Laufwerks, das Sie im vorherigen Schritt erstellt haben.
    • NAMESPACE: der Ziel-Namespace.
    • DISK_SIZE: Die gewünschte Laufwerkgröße. Muss der Größe des VM-Laufwerks entsprechen, das Sie im vorherigen Schritt erstellt haben.

  3. Ändern Sie die Größe des Ziellaufwerks mit dem folgenden Befehl in die gewünschte Größe:

    kubectl edit gdisk DISK_NAME -n NAMESPACE

    Ersetzen Sie Folgendes:

    • DISK_NAME: der Name des VM-Laufwerks, das Sie im vorherigen Schritt erstellt haben.
    • NAMESPACE: der Ziel-Namespace.

  4. Ändern Sie den Wert spec.size in der Konfiguration des Laufwerks und wenden Sie ihn auf Ihren Cluster an.

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.

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
   autoRestartOnConfigurationChange: true 
   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

Führen Sie die Schritte in diesem Abschnitt aus, um die Anmeldedaten zu erhalten, die für den Zugriff auf Ihre VM über die Linux-Gastumgebung erforderlich sind.

  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: {}
 autoRestartOnConfigurationChange: 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.

Nächste Schritte