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 :

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 :

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

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