Créer et gérer des disques virtuels dans GDCV pour Bare Metal

Ce document est destiné aux propriétaires d'applications qui exécutent GKE sur une solution Bare Metal. Ce document explique comment créer et gérer des ressources de disque pour les machines virtuelles (VM) qui utilisent l'environnement d'exécution des VM sur GDC.

Avant de commencer

Pour suivre les instructions de ce document, vous devez disposer des ressources suivantes :

Accès à GKE sur un cluster Bare Metal version 1.12.0 (anthosBareMetalVersion: 1.12.0) ou ultérieure. Vous pouvez utiliser n'importe quel type de cluster capable d'exécuter des charges de travail. Si nécessaire, essayez GDCV pour Bare Metal sur Compute Engine ou consultez la présentation de la création de clusters.
L'outil client virtctl, installé en tant que plug-in de kubectl. Si nécessaire, installez l'outil client virtctl.

Créer une VM avec un disque associé

Lorsque vous créez une VM, vous pouvez associer un disque de démarrage ou de données existant, créer un disque à partir d'une image (y compris pour le disque de démarrage) ou créer un disque vide.

Disque vide

Dans ce scénario, vous créez un disque vide et vous l'associez à la VM. Ce scénario vous permet de créer un disque de données afin de stocker les données de votre application.

Dans l'éditeur de votre choix, créez un fichier manifeste qui définit un VirtualMachineDisk et une VirtualMachine, tel que my-vm.yaml :
```
nano my-vm.yaml
```
Copiez et collez la définition YAML suivante :
```
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
```
Remplacez les éléments suivants :
- DISK_NAME: nom du disque vide que vous créez et associez à votre VM.
  
  Remarque :À partir de la version 1.13.0 de GKE sur Bare Metal, l'environnement d'exécution de VM sur GDC définit les noms de disque spécifiés avec virtualMachineDiskName comme numéro de série lorsque vous créez une VM. Pour en savoir plus, consultez la section Trouver des disques.
- VM_NAME: nom de la VM que vous créez.
  
  Cet exemple crée un disque vide 10Gi (10 gibioctets) nommé DISK_NAME. Dans la section spec.disks de la VM, vous devez également associer un disque de démarrage, par exemple à partir d'une image, comme illustré dans la section suivante.
Enregistrez et fermez le fichier manifeste dans l'éditeur.
Créez la VM et le disque en utilisant kubectl :
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Remplacez KUBECONFIG par le chemin d'accès au fichier kubeconfig du cluster.

À partir de l'image

Dans ce scénario, vous créez un disque à partir d'une image et vous l'associez à la VM. Ce scénario vous permet de créer un disque de démarrage, par exemple à partir d'une image. Vous pouvez également créer et associer des disques de données à partir d'une image.

Sources d'images compatibles

L'environnement d'exécution de VM sur GDC autorise différents formats d'image et accepte trois types de sources d'image pouvant être spécifiés dans la spécification VirtualMachineDisk. Chacun des exemples suivants crée un disque de 20 gibioctets à partir d'une source d'image compatible différente.

Protocole de transfert Hypertext (HTTP)

L'exemple VirtualMachineDisk suivant montre la structure de base d'une source d'image HTTP. Le champ url attend une URL HTTP ou HTTPS.

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

L'exemple suivant montre comment créer un disque à partir d'une image stockée dans un bucket Cloud Storage. Si les identifiants par défaut de l'application sur la machine ne sont pas suffisants pour accéder à l'URL Cloud Storage, vous devez en fournir. Dans l'exemple suivant, my-gcs est un secret contenant une clé de compte de service encodée en base64.
```
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
```
Si vous avez utilisé des clés de compte de service téléchargées pour créer votre cluster, vous pouvez utiliser la clé de compte de service Container Registry pour un accès Cloud Storage. Si vous créez un compte de service distinct pour accéder à Cloud Storage, consultez la section Configurer un compte de service pouvant accéder à un bucket Cloud Storage.

Utilisez la commande suivante pour créer un secret Kubernetes à partir du fichier de clé de compte de service téléchargé :
```
kubectl create secret generic SECRET_NAME --from-file=KEY_FILE --namespace default \
    --kubeconfig KUBECONFIG
```
Remplacez les éléments suivants :
- SECRET_NAME: nom de votre secret.
- KEY_FILE: chemin d'accès au fichier JSON de clé de compte de service téléchargé. Par exemple, bmctl-workspace/.sa-keys/my-project-anthos-baremetal-gcr.json.
- KUBECONFIG: chemin d'accès au fichier kubeconfig du cluster.
Pour en savoir plus sur l'utilisation des identifiants pour accéder à Cloud Storage, consultez la page Créer et utiliser des identifiants pour importer des images à partir de Cloud Storage.
Exemple Container Registry

Les registres de conteneurs conformes à la distribution-spec de l'Open Container Initiative (OCI) sont disponibles. L'exemple suivant crée un disque à partir d'une image stockée dans un registre Docker.
```
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
```

Formats d'image valides

Vous pouvez utiliser l'un des formats d'image suivants lorsque vous créez un disque à partir d'une image:

Archive GNU ZIP (gzip) (.gz)
RAW (.raw, .img)
Copie QEMU sur l'image disque (écriture version 2) (qcow2) (.qcow2)
Archive compressée au format XZ (.xz)
Fichier de disque de machine virtuelle (VMDK) (.vmdk)
Fichier VDI (VirtualBox Virtual Disk Image) (.vdi)
Fichier d'image de disque dur virtuel (VHD) (.vdh)
Fichier de disque dur virtuel version 2 (VDHX) (.vdhx)
Fichier image de disque ISO (.iso)

Exemple de disque créé à partir d'une image HTTP

La procédure suivante permet de créer un disque de démarrage à partir d'une image Ubuntu:

Créez un fichier manifeste définissant des fichiers VirtualMachineDisk et VirtualMachine (my-vm.yaml,, par exemple) dans l'éditeur de votre choix :
```
nano my-vm.yaml
```

Copiez et collez la définition YAML suivante :

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

Cet exemple crée un disque 20Gi (20 gibioctets) nommé VM_NAME-boot-dv à l'aide d'une image Ubuntu publique. Dans la section spec.disks de la VM, le disque est défini sur boot: true.

Enregistrez et fermez le fichier manifeste dans votre éditeur.
Créez la VM et le disque en utilisant kubectl :
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Remplacez KUBECONFIG par le chemin d'accès au fichier kubeconfig du cluster.

Disque existant

Dans ce scénario, vous créez un disque vide et vous l'associez à la VM. Ce scénario vous permet de créer un disque de données afin de stocker les données de votre application.

Créez un fichier manifeste VirtualMachine (my-vm.yaml,, par exemple) dans l'éditeur de votre choix :
```
nano my-vm.yaml
```

Copiez et collez la définition YAML suivante :

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

Cet exemple associe un disque existant nommé EXISTING_DISK_NAME.

Dans la section spec.disks de la VM, vous devez également associer un disque de démarrage, par exemple à partir d'une image, comme illustré dans la section précédente.

Enregistrez et fermez le fichier manifeste de la VM dans votre éditeur.
Créez la VM en utilisant kubectl :
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Remplacez KUBECONFIG par le chemin d'accès au fichier kubeconfig du cluster.

Localiser les disques

À partir de la version 1.13.0 de GKE sur Bare Metal, lorsque vous créez une VM, l'environnement d'exécution de VM sur GDC utilise les noms de disque que vous spécifiez dans la ressource de VM pour définir les numéros de série des disques. Plus précisément, les noms que vous spécifiez avec spec.disks.virtualMachineDiskName dans la ressource personnalisée VirtualMachine sont utilisés dans le numéro de série des disques. Cette fonctionnalité facilite la localisation des disques dans la VM lorsque vous devez effectuer des opérations sur les disques, telles que la mise en forme ou l'installation.

Par exemple, si vous avez créé une VM et spécifié un disque de démarrage nommé sample-boot-dv, votre ressource personnalisée VirtualMachine ressemble à ceci:

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

Pour les VM Linux, lorsque vous vous connectez à votre VM, vous pouvez exécuter la commande suivante pour répertorier les disques par leur numéro de série:

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

Votre réponse doit ressembler à cet exemple de résultat, où les noms des disques apparaissent sous forme de numéros de série:

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

Observez le comportement de la situation suivante:

Si la valeur virtualMachineDiskName comporte plus de 20 caractères, l'environnement d'exécution de VM sur GDC n'utilise que les 20 premiers caractères comme numéro de série.
S'il existe deux disques avec les mêmes 20 premiers caractères, seul le premier disque possède un numéro de série.

Créer et associer des disques à une VM existante

Si vous disposez déjà d'une VM, vous pouvez créer et associer des disques pour gérer le cycle de vie de votre application. La VM doit être arrêtée pour pouvoir lui associer un disque.

Disque vide

Dans ce scénario, vous créez un disque vide et vous l'associez à la VM. Ce scénario vous permet de créer un disque de données afin de stocker les données de votre application.

Utilisez kubectl pour arrêter la VM, si nécessaire :
```
kubectl virt stop vm VM_NAME --kubeconfig KUBECONFIG
```
Remplacez les éléments suivants :
- VM_NAME : nom de la VM que vous souhaitez mettre arrêter.
- KUBECONFIG : chemin d'accès au fichier kubeconfig du cluster.
Modifiez la ressource de VM existante, telle que my-vm :
```
kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG
```

Mettez à jour le fichier manifeste VirtualMachine pour ajouter une section VirtualMachineDisk en haut, puis associez le disque à la fin de la section spec.disks de la VM :

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

Cet exemple crée un disque vide 10Gi (10 gibioctets) nommé DISK_NAME.

Enregistrez et fermez le fichier manifeste mis à jour de la VM dans votre éditeur.

Utilisez kubectl pour démarrer la VM :

kubectl virt start vm VM_NAME --kubeconfig KUBECONFIG

À partir de l'image

Dans ce scénario, vous créez un disque à partir d'une image source et vous l'associez à la VM.

Utilisez kubectl pour arrêter la VM, si nécessaire :
```
kubectl virt stop vm VM_NAME --kubeconfig KUBECONFIG
```
Remplacez les éléments suivants :
- VM_NAME : nom de la VM que vous souhaitez mettre arrêter.
- KUBECONFIG : chemin d'accès au fichier kubeconfig du cluster.
Modifiez la ressource de VM existante, telle que my-vm :
```
kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG
```

Mettez à jour le fichier manifeste VirtualMachine pour ajouter une section VirtualMachineDisk en haut, puis associez le disque à la fin de la section spec.disks de la VM :

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

Cet exemple crée un disque 10Gi (10 gibioctets) nommé DISK_NAME à partir de la source HTTP http://example.com/my-disk-img.qcow2.

Enregistrez et fermez le fichier manifeste mis à jour de la VM dans votre éditeur.

Utilisez kubectl pour démarrer la VM :

kubectl virt start vm VM_NAME --kubeconfig KUBECONFIG

Créer un disque

Dans ce scénario, vous créez les ressources de disque séparément des ressources de VM. Ce scénario vous permet de créer des disques à l'avance, puis de les associer à des VM au besoin.

Disque vide

Pour créer un disque vide, procédez comme suit :

Créez un fichier manifeste VirtualMachineDisk (my-disk.yaml,, par exemple) dans l'éditeur de votre choix :
```
nano my-disk.yaml
```
Copiez et collez la définition YAML suivante :
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
```
Cet exemple crée un disque vide 10Gi (10 gibioctets) nommé DISK_NAME.
Enregistrez et fermez le fichier manifeste de disque dans votre éditeur.
Créez le disque en utilisant kubectl :
```
kubectl apply -f my-disk.yaml --kubeconfig KUBECONFIG
```
Remplacez KUBECONFIG par le chemin d'accès au fichier kubeconfig du cluster.

À partir de l'image

Pour créer un disque à partir d'une image, procédez comme suit :

Créez un fichier manifeste VirtualMachineDisk, tel que my-disk.yaml, dans l'éditeur de votre choix :
```
nano my-disk.yaml
```

Copiez et collez la définition YAML suivante :

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

Cet exemple crée un disque 20Gi (20 gibioctets) nommé DISK_NAME à l'aide d'une image Ubuntu publique.

Enregistrez et fermez le fichier manifeste de disque dans votre éditeur.
Créez le disque en utilisant kubectl :
```
kubectl apply -f my-disk.yaml --kubeconfig KUBECONFIG
```
Remplacez KUBECONFIG par le chemin d'accès au fichier kubeconfig du cluster.

Étapes suivantes

Créer et utiliser des identifiants pour importer des images à partir de Cloud Storage
Créez et utilisez des classes de stockage dans GDCV pour Bare Metal.
Lorsque vous n'avez plus besoin de VM ni de leurs ressources de disque virtuel, supprimez une VM dans GKE sur une solution Bare Metal.