Tutoriel : Créer et gérer une VM Linux dans l'environnement d'exécution des VM Anthos

---

Version 1.13 

• Le plus récent
• Version 1.16
• Versions antérieures (non compatibles)

Ce tutoriel explique comment créer et gérer une machine virtuelle (VM) Linux sur une nouvelle installation de l'environnement d'exécution des VM Anthos. 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 objet StorageClass pour l'environnement d'exécution des VM Anthos
  • 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 :

• Accès aux clusters Anthos sur solution Bare Metal version 1.12.0 (anthosBareMetalVersion: 1.12.0) ou cluster supérieur. Vous pouvez utiliser n'importe quel type de cluster capable d'exécuter des charges de travail. Si nécessaire, essayez les clusters Anthos sur solution 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 Anthos 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 :

1. Créez un fichier manifeste Network, tel que dhcp-network.yaml, dans l'éditeur de votre choix :

   nano dhcp-network.yaml
   

2. Copiez et collez le fichier manifeste YAML suivant :

   apiVersion: networking.gke.io/v1
   kind: Network
     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 sur vos nœuds de clusters Anthos sur solution Bare Metal auquel associer le réseau. 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 type de réseau que vous pouvez créer dans l'environnement d'exécution des VM Anthos.
   • 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.

3. Enregistrez et fermez le fichier manifeste Network dans votre éditeur.

4. 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 :

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

   nano my-disk.yaml
   

2. 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.

3. Enregistrez et fermez le fichier manifeste VirtualMachineDisk dans votre éditeur.

4. 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.

Remarque : Lorsque vous créez une VM à partir d'un fichier manifeste YAML, vous pouvez la configurer pour qu'elle ait une initialisation personnalisée chaque fois qu'elle démarre. Pour connaître les conditions préalables et les instructions concernant la configuration d'une nouvelle VM avec des routines de démarrage, consultez la page Configurer les routines de démarrage de VM.

1. 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
   

2. 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.

3. Enregistrez et fermez le fichier manifeste dans votre éditeur.

4. Créez la VM et le disque en utilisant kubectl :

   kubectl apply -f my-vm.yaml
   

5. 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.

1. Pour accéder à une VM depuis la console, utilisez kubectl :

   kubectl virt ssh VM_NAME
   

2. 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.

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

   nano my-data-disk.yaml
   

2. 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.

3. Enregistrez et fermez le fichier manifeste de disque dans votre éditeur.

4. Créez le disque en utilisant kubectl :

   kubectl apply -f my-data-disk.yaml
   

5. Utilisez kubectl pour arrêter votre VM avant d'associer le nouveau disque virtuel :

   kubectl virt stop VM_NAME
   

6. 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.

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

8. 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 :

1. Supprimer votre VM

   kubectl delete -f my-vm.yaml
   

2. 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 :

1. Supprimez votre réseau virtuel :

   kubectl delete -f use-dhcp-network.yaml
   

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

Étapes suivantes

• Créer et utiliser des classes de stockage dans des clusters Anthos sur bare metal
• Créer et utiliser des réseaux virtuels dans des clusters Anthos sur bare metal
• Créer et gérer des disques virtuels dans des clusters Anthos sur bare metal
• Modifiez des VM dans des clusters Anthos sur solution Bare Metal.