Tutoriel: Créer et gérer une VM Linux dans l'environnement d'exécution des VM sur Google Distributed Cloud

Ce tutoriel explique comment créer et gérer une machine virtuelle (VM) Linux sur une nouvelle installation de l'environnement d'exécution de VM sur Google Distributed Cloud. Vous allez apprendre à créer et à définir les dépendances de base telles qu'un réseau StorageClass et un réseau virtuel, puis à créer une VM qui utilise ces ressources. Vous découvrirez ensuite comment modifier la VM, par exemple pour ajouter un disque.

Objectifs

Configurer les dépendances de base
- Créer un StorageClass pour l'environnement d'exécution des VM sur Google Distributed Cloud
- Créer un réseau virtuel à utiliser par les VM
Créer un disque de démarrage de machine virtuelle
Créer une VM
Modifier une VM pour ajouter un disque virtuel

Avant de commencer

Pour suivre ce tutoriel, vous devez avoir accès aux ressources et outils suivants :

Un accès à GKE sur bare metal version 1.12.0 (anthosBareMetalVersion: 1.12.0) ou à un cluster supérieur. Vous pouvez utiliser n'importe quel type de cluster capable d'exécuter des charges de travail. Si nécessaire, essayez GKE sur 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 un objet `StorageClass`

Vous utilisez un StorageClass pour définir le type de stockage que vous mettez à la disposition des VM. Différentes classes de stockage peuvent correspondre à différents types de matériel de stockage, systèmes de fichiers ou niveaux de performances.

Ce tutoriel n'a pas pour objectif de fournir des instructions spécifiques pour chaque StorageClass et partenaire de stockage.

Les partenaires de stockage Anthos Ready fournissent des pilotes Container Storage Interface (CSI) qualifiés qui installent et configurent les ressources personnalisées requises pour votre espace de stockage. Pour installer le pilote CSI dans votre cluster, consultez la liste des partenaires de stockage compatibles et suivez leurs instructions.

Une fois que vous avez installé le pilote CSI pour votre plate-forme de stockage, une ou plusieurs classes de stockage sont disponibles dans votre cluster. Dans ce tutoriel, vous allez utiliser l'une de ces classes de stockage pour créer un disque dur virtuel.

L'exemple de base NFS StorageClass suivant utilise le pilote CSI NFS. Vous définissez l'adresse du serveur NFS et le chemin d'accès à utiliser dans StorageClass. Tous les nœuds de votre cluster peuvent ensuite se connecter à cet espace de stockage NFS et l'utiliser :

  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

Dans ce tutoriel, utilisez le nom d'un StorageClass dans votre propre cluster.

L'environnement d'exécution des VM sur Google Distributed Cloud génère automatiquement un profil de stockage pour chaque StorageClass d'un cluster. Le profil de stockage porte le même nom que l'identifiant StorageClass associé. Les profils de stockage fournissent des options de configuration supplémentaires associées à chaque StorageClass. Pour en savoir plus sur les profils de stockage, y compris les instructions de configuration, consultez la section Configurer des profils de stockage.

Créer un réseau virtuel

Les VM se connectent à un réseau virtuel à l'aide d'une interface de réseau virtuel. Le réseau virtuel leur permet de communiquer avec d'autres VM du cluster ou avec des ressources en dehors du cluster.

Dans ce tutoriel, vous allez créer un réseau virtuel de base de couche 2 (L2) pouvant utiliser un serveur DHCP externe. Lorsque vous activez l'utilisation d'un serveur DHCP externe, vous pouvez ignorer la configuration des paramètres DNS et de la passerelle s'ils sont fournis par DHCP.

Pour créer un réseau utilisant un serveur DHCP externe, procédez comme suit :

Créez un fichier manifeste Network, tel que dhcp-network.yaml, dans l'éditeur de votre choix :
```
nano dhcp-network.yaml
```
Copiez et collez le fichier manifeste YAML suivant :
```
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: NETWORK_NAME
spec:
  type: L2
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
Remplacez les valeurs suivantes :
- NETWORK_NAME : nom de votre réseau.
- INTERFACE_NAME: nom de l'interface de votre nœud GKE sur Bare Metal auquel le réseau doit être associé. Tous les nœuds doivent avoir le même nom d'interface.
Dans ce fichier manifeste Network, les valeurs suivantes sont définies :
- Les charges de travail ne peuvent être associées qu'à un rattachement L2 (de couche 2) sur ce réseau. Il s'agit du seul réseau type que vous pouvez créer dans l'environnement d'exécution des VM sur Google Distributed Cloud.
- Le serveur DHCP externe est activé sur le réseau. Le serveur DHCP externe est responsable de l'allocation d'adresses IPv4, des routes, de la passerelle et de la configuration DNS pour les charges de travail connectées à ce réseau.
Enregistrez et fermez le fichier manifeste Network dans votre éditeur.
Créez le réseau à l'aide de kubectl :
```
kubectl apply -f use-dhcp-network.yaml
```

Créer un disque de démarrage de VM

Une VM peut utiliser une image disque pré-créée ou démarrer à partir d'une image ISO pour installer manuellement le système d'exploitation. Ces images disque peuvent être stockées et accessibles via HTTP ou dans Cloud Storage, et accessibles à l'aide d'un Secret.

Dans ce tutoriel, vous allez créer un disque de démarrage à partir de l'image cloud publique d'Ubuntu Server 20.04 à l'aide de HTTP.

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
  storageClassName: STORAGE_CLASS_NAME
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
```
Remplacez les valeurs suivantes :
- DISK_NAME : nom que vous souhaitez pour votre disque. Cet exemple crée un disque 20Gi (20 gibioctets) nommé DISK_NAME à l'aide d'une image publique Ubuntu Server 20.04.
- STORAGE_CLASS_NAME : StorageClass que vous souhaitez utiliser pour votre VirtualMachineDisk.
  - Utilisez la commande kubectl get storageclass pour regrouper les éléments disponibles dans votre cluster.
Remarque : Le téléchargement de cette image publique, la création du VirtualMachineDisk et l'application de l'image de l'OS au nouveau disque peuvent prendre entre 15 et 20 minutes. Le processus de création du VirtualMachineDisk est beaucoup plus rapide lorsque vous utilisez une image stockée localement. Dans la plupart des scénarios de production, utilisez un dépôt d'images HTTP local plutôt que d'extraire à chaque fois depuis une source publique externe.
Enregistrez et fermez le fichier manifeste VirtualMachineDisk dans votre éditeur.
Créez le disque en utilisant kubectl :
```
kubectl apply -f my-disk.yaml
```

Créer une VM

Maintenant que vous disposez d'un réseau virtuel et d'un disque de démarrage créés dans les sections précédentes, vous pouvez créer une VM. La VM se connecte au réseau virtuel et démarre à partir du disque virtuel. Les instructions suivantes créent une VM en appliquant directement un fichier manifeste YAML VirtualMachine avec la CLI kubectl.

Dans l'éditeur de votre choix, créez un fichier manifeste qui définit un 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: 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
```
Remplacez les valeurs suivantes :
- VM_NAME : nom de votre VM.
- VCPU_NUMBER : (facultatif) nombre de processeurs virtuels à attribuer à la VM. Sans ce paramètre, la valeur par défaut de deux processeurs virtuels est attribuée.
  - Vous pouvez attribuer entre 1 et 96 processeurs virtuels à une VM.
- MEMORY_SIZE : quantité de mémoire à attribuer à la VM. Sans ce paramètre, la valeur par défaut de 4 Gio de mémoire est attribuée.
  - Vous pouvez attribuer entre 1 Mo et 1 To de mémoire à une VM. Pour en savoir plus, consultez la section Unités de ressource de mémoire.
- NETWORK_NAME : nom de votre réseau créé dans une section précédente.
- DISK_NAME : nom du disque de démarrage créé à la section précédente. Ce 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
```
La création de la VM peut prendre quelques minutes. Vérifiez l'état de la VM à l'aide de la commande kubectl :
```
kubectl get gvm VM_NAME
```
L'exemple de résultat suivant affiche la VM à l'état Running :
```
NAME    STATUS    AGE   IP
MY_VM   Running   64s   192.168.2.124
```

Se connecter à la VM

Lorsque votre VM est en cours d'exécution, connectez-vous à sa console. Cette connexion à la console vous permet d'effectuer des tâches de base telles que la configuration de la VM ou l'installation d'une application.

Pour accéder à une VM depuis la console, utilisez kubectl :
```
kubectl virt ssh VM_NAME
```
Une fois que vous êtes connecté à la console de la VM, quittez la session et la console de la VM :
```
Ctrl + ]
```

Modifier la VM

Au cours du cycle de vie de votre VM, vous pourriez avoir besoin de la modifier. Par exemple, vous souhaiterez peut-être ajouter de l'espace de stockage pour installer une application sur un disque dédié ou utiliser de l'espace de stockage supplémentaire pour votre application.

Dans ce tutoriel, créez un disque vide et associez-le à 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 VirtualMachineDisk, tel que my-data-disk.yaml, dans l'éditeur de votre choix :
```
nano my-data-disk.yaml
```
Copiez et collez la définition YAML suivante :
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DATA_DISK_NAME
spec:
  size: 10Gi
  storageClassName: STORAGE_CLASS_NAME
```
Remplacez les valeurs suivantes :
- DATA_DISK_NAME : nom que vous souhaitez pour votre disque. Cet exemple crée un disque de 10Gi (10 gibioctets).
- STORAGE_CLASS_NAME : StorageClass que vous souhaitez utiliser pour votre VirtualMachineDisk.
  - Utilisez la commande kubectl get storageclass pour regrouper les éléments disponibles dans votre cluster.
Enregistrez et fermez le fichier manifeste de disque dans votre éditeur.
Créez le disque en utilisant kubectl :
```
kubectl apply -f my-data-disk.yaml
```
Utilisez kubectl pour arrêter votre VM avant d'associer le nouveau disque virtuel :
```
kubectl virt stop VM_NAME
```

Modifiez votre ressource de VM :

kubectl edit gvm VM_NAME

Mettez à jour le fichier manifeste YAML VirtualMachine à associer au disque à la fin de la section spec.disks :

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

Remplacez DATA_DISK_NAME par le nom du disque créé à l'étape précédente.

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_NAME
```

Effectuer un nettoyage

Pour supprimer les ressources créées dans ce tutoriel, procédez comme suit :

Supprimer votre VM
```
kubectl delete -f my-vm.yaml
```

Supprimez vos ressources VirtualMachineDisk :

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

Si vous ne souhaitez pas conserver les dépendances de base de votre cluster, procédez comme suit :

Supprimez votre réseau virtuel :

kubectl delete -f use-dhcp-network.yaml

Pour supprimer le pilote CSI de votre cluster, suivez les instructions de votre partenaire de stockage.