Version 1.14. This version is no longer supported. For information about how to upgrade to version 1.15, see Upgrading Anthos on bare metal in the 1.15 documentation. For more information about supported and unsupported versions, see the Version history page in the latest documentation.

Virtuelle Laufwerke in GKE on Bare Metal erstellen und verwalten

Dieses Dokument richtet sich an Inhaber von Anwendungen, die GKE on Bare Metal ausführen. In diesem Dokument erfahren Sie, wie Sie Laufwerksressourcen für virtuelle Maschinen (VMs) erstellen und verwalten, die die VM-Laufzeit in Google Distributed Cloud verwenden.

Hinweise

Um dieses Dokument abzuschließen, benötigen Sie Zugriff auf die folgenden Ressourcen:

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

VM mit einem angehängten Laufwerk erstellen

Sie können beim Erstellen einer VM ein vorhandenes Start- oder Datenlaufwerk hinzufügen, ein Laufwerk aus einem Image erstellen (einschließlich des Bootlaufwerks) oder ein leeres Laufwerk erstellen.

Leeres Laufwerk

In diesem Szenario 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 im Editor Ihrer Wahl ein Manifest, in dem VirtualMachineDisk und VirtualMachine definiert sind, z. B. my-vm.yaml:
```
nano my-vm.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: 10Gi
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME
```
Ersetzen Sie Folgendes:
- DISK_NAME: Name des leeren Laufwerks, das Sie erstellen und an Ihre VM anhängen
  
  Hinweis: Ab GKE on Bare Metal Version 1.13.0 legt die VM-Laufzeit in Google Distributed Cloud beim Erstellen einer VM die Laufwerksnamen fest, die mit virtualMachineDiskName als Seriennummer für das Laufwerk angegeben sind. Weitere Informationen finden Sie unter Laufwerke finden.
- VM_NAME: der Name der VM, die Sie erstellen.
  
  In diesem Beispiel wird ein leeres 10Gi-Laufwerk (10 Gibibyte) mit dem Namen DISK_NAME erstellt. Im Abschnitt spec.disks der VM müssen Sie auch ein Bootlaufwerk anhängen, z. B. von einem Image, wie im nächsten Abschnitt gezeigt.
Speichern und schließen Sie die Manifestdatei in Ihrem Editor.
Erstellen Sie die VM und das Laufwerk mit kubectl:
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Ersetzen Sie KUBECONFIG durch den Pfad zur kubeconfig-Datei des Clusters.

Image

In diesem Szenario erstellen Sie ein Laufwerk aus einem Image und hängen es an die VM an. In diesem Szenario können Sie ein Bootlaufwerk erstellen, z. B. aus einem Image. Sie können auch Datenlaufwerke aus einem Image erstellen und anhängen.

Unterstützte Bildquellen

VM-Laufzeit in Google Distributed Cloud ermöglicht eine Vielzahl von Bildformaten und unterstützt drei Typen von Bildquellen, die in der VirtualMachineDisk-Spezifikation angegeben werden können. In jedem der folgenden Beispiele werden 20 Gibibyte-Laufwerke aus einer anderen unterstützten Image-Quelle erstellt.

HyperText Transfer Protocol (HTTP)

Das folgende VirtualMachineDisk-Beispiel zeigt die Grundstruktur einer HTTP-Bildquelle. Das Feld url erwartet entweder eine HTTP- oder eine HTTPS-URL.

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: my-disk
spec:
  source:
    http:
      url: https://download.cirros-cloud.net/0.4.0/cirros-0.4.0-x86_64-disk.img
  size: 20GiB
  storageClassName: local-shared

Cloud Storage

Das folgende Beispiel zeigt, wie Sie ein Laufwerk aus einem Image in einem Cloud Storage-Bucket erstellen. Wenn die Standardanmeldedaten auf dem Computer für den Zugriff auf die Cloud Storage-URL nicht ausreichen, müssen Sie Anmeldedaten angeben. Im folgenden Beispiel ist my-gcs ein Secret mit einem base64-codierten Dienstkontoschlüssel.
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: my-disk
spec:
  source:
    gcs:
      url: gs://kubevirt-ci-vm-images/rhel8.2/rhel8_2_cloud.qcow2
      secretRef: my-gcs
  size: 20GiB
  storageClassName: local-shared
```
Wenn Sie zum Erstellen des Clusters heruntergeladene Dienstkontoschlüssel verwendet haben, können Sie den Container Registry-Dienstkontoschlüssel für den Cloud Storage-Zugriff verwenden. Wenn Sie ein separates Dienstkonto für den Zugriff auf Cloud Storage erstellen, lesen Sie die Informationen unter Dienstkonto konfigurieren, das auf einen Cloud Storage-Bucket zugreifen kann.

Verwenden Sie den folgenden Befehl, um ein Kubernetes Secret aus der heruntergeladenen Schlüsseldatei des Dienstkontos zu erstellen:
```
kubectl create secret generic SECRET_NAME --from-file=KEY_FILE --namespace default \
    --kubeconfig KUBECONFIG
```
Ersetzen Sie Folgendes:
- SECRET_NAME ist der Name für Ihr Secret.
- KEY_FILE: Pfad zur heruntergeladenen JSON-Datei des Dienstkontoschlüssels. Beispiel: bmctl-workspace/.sa-keys/my-project-anthos-baremetal-gcr.json.
- KUBECONFIG: Pfad zur kubeconfig-Datei des Clusters.
Weitere Informationen zum Verwenden von Anmeldedaten für den Zugriff auf Cloud Storage finden Sie unter Anmeldedaten zum Importieren von Images aus Cloud Storage erstellen und verwenden.
Container Registry-Beispiel

Container-Registries, die der Vertriebsspezifikation der Open Container Initiative (OCI) entsprechen, werden unterstützt. Im folgenden Beispiel wird ein Laufwerk aus einem Image erstellt, das in einer Docker-Registry gespeichert ist.
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: my-disk
spec:
  source:
    registry:
      url: docker://kubevirt/fedora-cloud-registry-disk-demo
  size: 20GiB
  storageClassName: local-shared
```

Gültige Bildformate

Wenn Sie ein Laufwerk aus einem Image erstellen, können Sie eines der folgenden Image-Formate verwenden:

GNU-ZIP-Archiv (gzip) (.gz)
RAW (.raw, .img)
QEMU-Kopie auf Laufwerk-Image mit Schreibversion 2 (qcow2) (.qcow2)
XZ-komprimiertes Archiv (.xz)
VMDK-Datei (.vmdk) (Virtual Machine Disk)
VDI-Datei (VirtualBox Virtual Disk Image) (.vdi)
VHD-Image-Datei (.vdh)
VDHX-Datei (Virtual Hard Disk Version 2) (.vdhx)
ISO-CD-Image-Datei (.iso)

Beispiel für ein Laufwerk, das aus einem HTTP-Image erstellt wurde

Mit den folgenden Schritten erstellen Sie ein Bootlaufwerk aus einem Ubuntu-Image:

Erstellen Sie ein Manifest, das eine VirtualMachineDisk und VirtualMachine definiert, z. B. my-vm.yaml, in dem Editor Ihrer Wahl:
```
nano my-vm.yaml
```

Kopieren Sie die folgende YAML-Definition und fügen Sie sie ein:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: VM_NAME-boot-dv
spec:
  size: 20Gi
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv

In diesem Beispiel wird ein 20Gi-Laufwerk (20 Gibibyte) mit dem Namen VM_NAME-boot-dv mithilfe eines öffentlichen Ubuntu-Images erstellt. Im Abschnitt spec.disks der VM wird das Laufwerk auf boot: true gesetzt.

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 --kubeconfig KUBECONFIG
```
Ersetzen Sie KUBECONFIG durch den Pfad zur kubeconfig-Datei des Clusters.

Vorhandenes Laufwerk

In diesem Szenario 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 VirtualMachine-Manifest wie my-vm.yaml,:
```
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:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: EXISTING_DISK_NAME

In diesem Beispiel wird ein vorhandenes Laufwerk mit dem Namen EXISTING_DISK_NAME angehängt.

Im Abschnitt spec.disks der VM müssen Sie auch ein Bootlaufwerk anhängen, z. B. von einem Image, wie im vorherigen Abschnitt gezeigt.

Speichern und schließen Sie das VM-Manifest in Ihrem Editor.
Erstellen Sie die VM mit kubectl:
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Ersetzen Sie KUBECONFIG durch den Pfad zur kubeconfig-Datei des Clusters.

Laufwerke suchen

Ab GKE on Bare Metal Version 1.13.0 verwendet die VM-Laufzeit in Google Distributed Cloud beim Erstellen einer VM die Laufwerknamen, die Sie in der VM-Ressource angeben, um die Seriennummern von Laufwerken festzulegen. Insbesondere die Namen, die Sie mit spec.disks.virtualMachineDiskName in der benutzerdefinierten Ressource VirtualMachine angeben, werden in der Seriennummer der Laufwerke verwendet. Dieses Feature erleichtert das Auffinden der Laufwerke in der VM, wenn Sie Laufwerkvorgänge wie das Formatieren oder Bereitstellen ausführen müssen.

Wenn Sie beispielsweise eine VM erstellt und ein Bootlaufwerk mit dem Namen sample-boot-dv angegeben haben, sieht Ihre benutzerdefinierte Ressource VirtualMachine in etwa so aus:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: sample-vm
spec:
  osType: Linux
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: sample-vm-boot-dv
    - virtualMachineDiskName: attached-disk

Bei Linux-VMs können Sie nach der Anmeldung bei der VM den folgenden Befehl ausführen, um Laufwerke nach Seriennummer aufzulisten:

ls -l /dev/disk/by-id/

Die Antwort sollte in etwa wie in der folgenden Beispielausgabe aussehen, wobei die Namen der Laufwerke als Seriennummern angezeigt werden:

total 0
lrwxrwxrwx 1 root root  9 Oct 19 17:17 ata-QEMU_HARDDISK_agentInstallation -> ../../sdb
lrwxrwxrwx 1 root root  9 Oct 19 17:17 ata-QEMU_HARDDISK_agentSADisk -> ../../sda
lrwxrwxrwx 1 root root  9 Oct 19 17:17 virtio-sample-boot-dv -> ../../vda
lrwxrwxrwx 1 root root 10 Oct 19 17:17 virtio-sample-boot-dv-part1 -> ../../vda1
lrwxrwxrwx 1 root root 11 Oct 19 17:17 virtio-sample-boot-dv-part14 -> ../../vda14
lrwxrwxrwx 1 root root 11 Oct 19 17:17 virtio-sample-boot-dv-part15 -> ../../vda15
lrwxrwxrwx 1 root root 11 Oct 19 17:17 virtio-attached-disk -> ../../vdb

Beachten Sie das folgende situative Featureverhalten:

Wenn der Wert virtualMachineDiskName länger als 20 Zeichen ist, verwendet VM-Laufzeit in Google Distributed Cloud nur die ersten 20 Zeichen als Seriennummer.
Wenn zwei Datenträger mit denselben ersten 20 Zeichen vorhanden sind, hat nur das erste Laufwerk eine Seriennummer.

Laufwerke erstellen und an vorhandene VM anhängen

Wenn Sie bereits eine VM haben, können Sie Laufwerke erstellen und anhängen, um die Anwendungslebenszyklen zu unterstützen. Die VM muss deaktiviert sein, bevor Sie ein Laufwerk anhängen.

Leeres Laufwerk

In diesem Szenario 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.

Verwenden Sie kubectl, um die VM bei Bedarf zu beenden:
```
kubectl virt stop vm VM_NAME --kubeconfig KUBECONFIG
```
Ersetzen Sie Folgendes:
- VM_NAME: der Name der VM, die Sie beenden möchten.
- KUBECONFIG: der Pfad zur kubeconfig-Datei des Clusters
Bearbeiten Sie Ihre vorhandene VM-Ressource, z. B. my-vm:
```
kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG
```

Aktualisieren Sie das YAML-Manifest VirtualMachine, um oben einen Abschnitt VirtualMachineDisk hinzuzufügen, und hängen Sie dann das Laufwerk am Ende des Abschnitts spec.disks der VM an:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME

In diesem Beispiel wird ein leeres 10Gi-Laufwerk (10 Gibibyte) mit dem Namen DISK_NAME erstellt.

Speichern und schließen Sie das aktualisierte VM-Manifest in Ihrem Editor.

Starten Sie die VM mit kubectl:

kubectl virt start vm VM_NAME --kubeconfig KUBECONFIG

Image

In diesem Szenario erstellen Sie ein Laufwerk aus einem Quell-Image und hängen es an die VM an.

Verwenden Sie kubectl, um die VM bei Bedarf zu beenden:
```
kubectl virt stop vm VM_NAME --kubeconfig KUBECONFIG
```
Ersetzen Sie Folgendes:
- VM_NAME: der Name der VM, die Sie beenden möchten.
- KUBECONFIG: der Pfad zur kubeconfig-Datei des Clusters
Bearbeiten Sie Ihre vorhandene VM-Ressource, z. B. my-vm:
```
kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG
```

Aktualisieren Sie das VirtualMachine-Manifest, um oben einen Abschnitt VirtualMachineDisk hinzuzufügen. Hängen Sie dann das Laufwerk am Ende des Abschnitts spec.disks der VM an:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
  source:
    http:
      url: http://example.com/my-disk-img.qcow2
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME

In diesem Beispiel wird ein 10Gi-Laufwerk (10 Gibibyte) mit dem Namen DISK_NAME aus der HTTP-Quelle http://example.com/my-disk-img.qcow2 erstellt.

Speichern und schließen Sie das aktualisierte VM-Manifest in Ihrem Editor.

Starten Sie die VM mit kubectl:

kubectl virt start vm VM_NAME --kubeconfig KUBECONFIG

Laufwerk erstellen

In diesem Szenario erstellen Sie die Laufwerkressourcen getrennt von den VM-Ressourcen. In diesem Szenario können Sie Laufwerke im Voraus erstellen und dann nach Bedarf an VMs anhängen.

Leeres Laufwerk

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

Erstellen Sie in einem Editor Ihrer Wahl ein VirtualMachineDisk-Manifest wie z. B. 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: 10Gi
```
In diesem Beispiel wird ein leeres 10Gi-Laufwerk (10 Gibibyte) mit dem Namen DISK_NAME erstellt.
Speichern und schließen Sie das Laufwerkmanifest in Ihrem Editor.
Erstellen Sie das Laufwerk mit kubectl:
```
kubectl apply -f my-disk.yaml --kubeconfig KUBECONFIG
```
Ersetzen Sie KUBECONFIG durch den Pfad zur kubeconfig-Datei des Clusters.

Image

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
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img

In diesem Beispiel wird ein 20Gi-Laufwerk (20 Gibibyte) mit dem Namen DISK_NAME mithilfe eines öffentlichen Ubuntu-Images erstellt.

Speichern und schließen Sie das Laufwerkmanifest in Ihrem Editor.
Erstellen Sie das Laufwerk mit kubectl:
```
kubectl apply -f my-disk.yaml --kubeconfig KUBECONFIG
```
Ersetzen Sie KUBECONFIG durch den Pfad zur kubeconfig-Datei des Clusters.

Nächste Schritte

Anmeldedaten erstellen und verwenden, um Images aus Cloud Storage zu importieren.
Speicherklassen in GKE on Bare Metal erstellen und verwenden
Wenn Sie keine VMs oder ihre virtuellen Laufwerksressourcen mehr benötigen, löschen Sie eine VM in GKE on Bare Metal.