Anthos Clusters on Bare Metal sind jetzt Google Distributed Cloud (nur Software) für Bare Metal. Weitere Informationen finden Sie in der Produktübersicht.

Anleitung: Linux-VM in der VM-Laufzeit auf GDC erstellen und verwalten

In dieser Anleitung erfahren Sie, wie Sie eine virtuelle Linux-Maschine (VM) in einer Neuinstallation der VM-Laufzeit auf GDC erstellen und verwalten. Sie erfahren, wie Sie die grundlegenden Abhängigkeiten wie ein StorageClass und ein virtuelles Netzwerk erstellen und definieren und dann eine VM erstellen, die diese Ressourcen verwendet. Anschließend erfahren Sie, wie Sie die VM bearbeiten, z. B. um ein neues Laufwerk hinzuzufügen.

Lernziele

Grundlegende Abhängigkeiten konfigurieren
- StorageClass für VM-Laufzeit in GDC erstellen
- Virtuelles Netzwerk für die VMs erstellen
VM-Bootlaufwerk erstellen
VM erstellen
VM bearbeiten, um ein neues virtuelles Laufwerk hinzuzufügen

Hinweise

Für diese Anleitung benötigen Sie Zugriff auf die folgenden Ressourcen und Tools:

Zugriff auf den Cluster GKE on Bare Metal Version 1.12.0 (anthosBareMetalVersion: 1.12.0) oder höher. Sie können einen beliebigen Clustertyp verwenden, der Arbeitslasten ausführen kann. Testen Sie bei Bedarf GKE on Bare Metal in Compute Engine oder sehen Sie sich die Übersicht über die Clustererstellung an.
Das virtctl-Clienttool, das als Plug-in für kubectl installiert wurde. Installieren Sie bei Bedarf das virtctl-Clienttool.

`StorageClass` erstellen

Mit einer StorageClass definieren Sie den Speichertyp, den Sie für VMs bereitstellen. Unterschiedliche Speicherklassen können einer unterschiedlichen Arten von Speicherhardware, Dateisystem oder Leistung zugeordnet werden.

Im Rahmen dieser Anleitung ist es nicht möglich, eine spezifische Anleitung für jeden StorageClass und jeden Speicherpartner bereitzustellen.

Mit Anthos kompatible Storage-Partner bieten qualifizierte CSI-Treiber (Container Storage Interface) zur Installation und Konfiguration der erforderlichen benutzerdefinierten Ressourcen für Ihren Speicher. Wenn Sie den CSI-Treiber in Ihrem Cluster installieren möchten, lesen Sie die Liste der unterstützten Speicherpartner und folgen Sie der Anleitung.

Nachdem Sie den CSI-Treiber für Ihre Speicherplattform installiert haben, sind eine oder mehrere Speicherklassen in Ihrem Cluster verfügbar. In dieser Anleitung verwenden Sie eine dieser Speicherklassen, um ein virtuelles Laufwerk zu erstellen.

Im folgenden grundlegenden Beispiel NFS StorageClass wird der NFS CSI-Treiber verwendet. Sie definieren die NFS-Serveradresse und den Pfad für die Verwendung in StorageClass. Alle Knoten in Ihrem Cluster können dann eine Verbindung zu diesem NFS-Speicher herstellen und diesen verwenden:

  apiVersion: storage.k8s.io/v1
  kind: StorageClass
  metadata:
    name: example-nfs
  provisioner: nfs.csi.k8s.io
  parameters:
    server: nfs-server.example.com
    path: /vm-share
  reclaimPolicy: Delete
  volumeBindingMode: Immediate
  mountOptions:
    - nconnect=8
    - nfsvers=4.1

In dieser Anleitung verwenden Sie den Namen eines StorageClass in Ihrem eigenen Cluster.

VM-Laufzeit auf GDC generiert automatisch ein Speicherprofil für jede StorageClass in einem Cluster. Das Speicherprofil hat den gleichen Namen wie die zugehörige StorageClass. Speicherprofile bieten zusätzliche Konfigurationsoptionen, die mit jedem StorageClass verknüpft sind. Weitere Informationen zu Speicherprofilen, einschließlich einer Konfigurationsanleitung, finden Sie unter Speicherprofile konfigurieren.

Virtuelles Netzwerk erstellen

VMs stellen über eine virtuelle Netzwerkschnittstelle eine Verbindung zu einem virtuellen Netzwerk her. Über das virtuelle Netzwerk können sie mit anderen VMs im Cluster oder mit Ressourcen außerhalb des Clusters kommunizieren.

In dieser Anleitung erstellen Sie ein einfaches virtuelles Netzwerk der Ebene 2 (L2), das einen externen DHCP-Server verwenden kann. Wenn Sie die Verwendung eines externen DHCP-Servers aktivieren, können Sie die Konfiguration der DNS- und Gateway-Einstellungen überspringen, sofern diese von DHCP bereitgestellt werden.

Führen Sie die folgenden Schritte aus, um ein Netzwerk zu erstellen, das einen externen DHCP-Server verwendet:

Erstellen Sie in einem Editor Ihrer Wahl ein Network-Manifest wie dhcp-network.yaml.
```
nano dhcp-network.yaml
```
Kopieren Sie das folgende YAML-Manifest und fügen Sie es ein:
```
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: NETWORK_NAME
spec:
  type: L2
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
Ersetzen Sie die folgenden Werte:
- NETWORK_NAME: Name des Netzwerks
- INTERFACE_NAME: der Schnittstellenname auf Ihrem GKE on Bare-Metal-Knoten, an den das Netzwerk angehängt werden soll. Alle Knoten sollten denselben Schnittstellennamen haben.
In diesem Network-Manifest werden die folgenden Werte festgelegt:
- Arbeitslasten können an dieses Netzwerk nur einen L2-Anhang haben. Dies ist das einzige Netzwerk-type, das Sie in der VM-Laufzeit auf GDC erstellen können.
- Im Netzwerk ist externes DHCP aktiviert. Der externe DHCP-Server ist für die Zuweisung von IPv4-Adressen, die Routen, das Gateway und die DNS-Konfiguration für mit diesem Netzwerk verbundene Arbeitslasten verantwortlich.
Speichern und schließen Sie das Manifest Network in Ihrem Editor.
Erstellen Sie das Netzwerk mit kubectl:
```
kubectl apply -f use-dhcp-network.yaml
```

VM-Bootlaufwerk erstellen

Eine VM kann ein vorab erstelltes Laufwerk-Image verwenden oder von einem ISO-Image starten, um das Betriebssystem manuell zu installieren. Diese Laufwerk-Images können über HTTP oder in Cloud Storage gespeichert und abgerufen werden und der Zugriff erfolgt über Secret.

In dieser Anleitung erstellen Sie mit HTTP ein Bootlaufwerk aus dem öffentlichen Cloud-Image von Ubuntu Server 20.04.

Führen Sie die folgenden Schritte aus, um ein Laufwerk aus einem Image zu erstellen.

Erstellen Sie in einem Editor Ihrer Wahl ein VirtualMachineDisk-Manifest wie my-disk.yaml.
```
nano my-disk.yaml
```
Kopieren Sie die folgende YAML-Definition und fügen Sie sie ein:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 20Gi
  storageClassName: STORAGE_CLASS_NAME
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
```
Ersetzen Sie die folgenden Werte:
- DISK_NAME ist der Name, den Sie für Ihr Laufwerk verwenden möchten. In diesem Beispiel wird ein 20Gi-Laufwerk (20 Gibibyte) mit dem Namen DISK_NAME mithilfe eines öffentlichen Ubuntu Server 20.04-Images erstellt.
- STORAGE_CLASS_NAME ist die StorageClass, die Sie für Ihre VirtualMachineDisk verwenden möchten.
  - Verwenden Sie kubectl get storageclass, um die in Ihrem Cluster verfügbaren Elemente aufzulisten.
Hinweis: Es kann 15–20 Minuten dauern, bis dieses öffentliche Image heruntergeladen, der VirtualMachineDisk erstellt und das Betriebssystem-Image auf das neue Laufwerk angewendet wurde. Der Vorgang zum Erstellen von VirtualMachineDisk ist viel schneller, wenn Sie ein lokal gespeichertes Image verwenden. Verwenden Sie für die meisten Produktionsszenarien ein lokales HTTP-Image-Repository und nicht jedes Mal eine externe öffentliche Quelle.
Speichern und schließen Sie das Manifest VirtualMachineDisk in Ihrem Editor.
Erstellen Sie das Laufwerk mit kubectl:
```
kubectl apply -f my-disk.yaml
```

VM erstellen

Erstellen Sie jetzt mit einem in den vorherigen Abschnitten erstellten virtuellen Netzwerk und einem Bootlaufwerk eine VM. Die VM stellt eine Verbindung zum virtuellen Netzwerk her und wird vom virtuellen Laufwerk gestartet. In der folgenden Anleitung wird eine VM durch direktes Anwenden einer YAML-Manifestdatei VirtualMachine mit der kubectl-Befehlszeile erstellt.

Erstellen Sie im Editor Ihrer Wahl ein Manifest, das eine VirtualMachine wie my-vm.yaml definiert:
```
nano my-vm.yaml
```
Kopieren Sie die folgende YAML-Definition und fügen Sie sie ein:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  osType: linux
  compute:
    cpu:
      vcpus: VCPU_NUMBER
    memory:
      capacity: MEMORY_SIZE
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
```
Ersetzen Sie die folgenden Werte:
- VM_NAME: der Name Ihrer VM.
- VCPU_NUMBER: die optionale Anzahl der vCPUs, die der VM zugewiesen werden sollen. Ohne diese Einstellung werden standardmäßig zwei vCPUs zugewiesen.
  - Sie können einer VM zwischen 1 und 96 vCPUs zuweisen.
- MEMORY_SIZE: die optionale Menge an Arbeitsspeicher, die der VM zugewiesen werden soll. Ohne diese Einstellung werden standardmäßig 4 GiB Arbeitsspeicher zugewiesen.
  - Sie können einer VM zwischen 1 M und 1 T Speicher zuweisen. Weitere Informationen finden Sie unter Arbeitsspeicherressourceneinheiten.
- NETWORK_NAME ist der Name Ihres Netzwerks, das in einem vorherigen Abschnitt erstellt wurde.
- DISK_NAME ist der Name des im vorherigen Abschnitt erstellten Bootlaufwerks. Dieses Laufwerk ist auf boot: true festgelegt.
Speichern und schließen Sie das Manifest in Ihrem Editor.
Erstellen Sie die VM und das Laufwerk mit kubectl:
```
kubectl apply -f my-vm.yaml
```
Es kann einige Minuten dauern, bis die VM erstellt ist. Prüfen Sie den Status der VM mit dem Befehl: kubectl
```
kubectl get gvm VM_NAME
```
Das folgende Ausgabebeispiel zeigt die VM im Status Running:
```
NAME    STATUS    AGE   IP
MY_VM   Running   64s   192.168.2.124
```

Verbindung zur VM herstellen

Wenn Ihre VM ausgeführt wird, stellen Sie eine Verbindung zur Konsole der VM her. Über diese Konsolenverbindung können Sie grundlegende Aufgaben ausführen, z. B. die VM weiter konfigurieren oder eine Anwendung installieren.

Verwenden Sie kubectl, um über die Console auf eine VM zuzugreifen:
```
kubectl virt console VM_NAME
```
Wenn Sie dazu aufgefordert werden, geben Sie die Nutzeranmeldedaten ein, die Sie zum Erstellen der VM angegeben haben.
Nachdem Sie erfolgreich eine Verbindung zur Konsole der VM hergestellt haben, beenden Sie die VM-Sitzung und die Console:
```
Ctrl + ]
```

Bearbeiten Sie die VM

Während des Lebenszyklus Ihrer VM sollten Sie Ihre VM bearbeiten. Sie können beispielsweise Speicher hinzufügen, um eine Anwendung auf einem dedizierten Laufwerk zu installieren, oder zusätzlichen Speicher für Ihre Anwendung verwenden.

In dieser Anleitung erstellen Sie ein leeres Laufwerk und hängen es an die VM an. In diesem Szenario können Sie ein Datenlaufwerk zum Speichern von Anwendungsdaten erstellen.

Erstellen Sie in einem Editor Ihrer Wahl ein VirtualMachineDisk-Manifest wie my-data-disk.yaml.
```
nano my-data-disk.yaml
```
Kopieren Sie die folgende YAML-Definition und fügen Sie sie ein:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DATA_DISK_NAME
spec:
  size: 10Gi
  storageClassName: STORAGE_CLASS_NAME
```
Ersetzen Sie die folgenden Werte:
- DATA_DISK_NAME: Der Name, den Sie für Ihr Datenlaufwerk verwenden möchten. In diesem Beispiel wird ein 10Gi-Laufwerk (10 Gibibyte) erstellt.
- STORAGE_CLASS_NAME ist die StorageClass, die Sie für Ihre VirtualMachineDisk verwenden möchten.
  - Verwenden Sie kubectl get storageclass, um die in Ihrem Cluster verfügbaren Elemente aufzulisten.
Speichern und schließen Sie das Laufwerkmanifest in Ihrem Editor.
Erstellen Sie das Laufwerk mit kubectl:
```
kubectl apply -f my-data-disk.yaml
```
Beenden Sie mit kubectl Ihre VM, bevor Sie das neue virtuelle Laufwerk anhängen:
```
kubectl virt stop VM_NAME
```

Bearbeiten Sie Ihre VM-Ressource:

kubectl edit gvm VM_NAME

Aktualisieren Sie das YAML-Manifest VirtualMachine, um das Laufwerk am Ende des Abschnitts spec.disks der VM anzuhängen:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  ...
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
    - virtualMachineDiskName: DATA_DISK_NAME

Ersetzen Sie DATA_DISK_NAME durch den Namen des im vorherigen Schritt erstellten Laufwerks.

Speichern und schließen Sie das aktualisierte VM-Manifest in Ihrem Editor.
Starten Sie die VM mit kubectl:
```
kubectl virt start VM_NAME
```

Bereinigen

Führen Sie die folgenden Schritte aus, um die in dieser Anleitung erstellten Ressourcen zu löschen:

Löschen Sie Ihre VM.
```
kubectl delete -f my-vm.yaml
```

Löschen Sie die VirtualMachineDisk-Ressourcen:

kubectl delete -f my-data-disk.yaml
kubectl delete -f my-disk.yaml

Wenn Sie die grundlegenden Abhängigkeiten in Ihrem Cluster nicht beibehalten möchten, führen Sie die folgenden Schritte aus:

Löschen Sie Ihr virtuelles Netzwerk:

kubectl delete -f use-dhcp-network.yaml

Folgen Sie der Anleitung Ihres Speicherpartners, um den CSI-Treiber aus Ihrem Cluster zu entfernen.