Ce tutoriel vous 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 GDC. 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 de VM sur GDC - Créer un réseau virtuel à utiliser par les VM
- Créer un
- 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 au cluster Google Distributed Cloud 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 Google Distributed Cloud sur Compute Engine ou consultez la présentation de la création de clusters. - L'outil client
virtctl
, installé en tant que plug-in dekubectl
. 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 Google Distributed Cloud Ready fournissent des pilotes CSI (Container Storage Interface) qualifiés qui installent et configurent les ressources personnalisées requises pour votre 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
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 GDC 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 quedhcp-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 Google Distributed Cloud 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 réseautype
que vous pouvez créer dans l'environnement d'exécution de VM sur GDC. - 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 quemy-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 disque20Gi
(20 gibioctets) nomméDISK_NAME
à l'aide d'une image publique Ubuntu Server 20.04.STORAGE_CLASS_NAME
:StorageClass
que vous souhaitez utiliser pour votreVirtualMachineDisk
.- Utilisez la commande
kubectl get storageclass
pour regrouper les éléments disponibles dans votre cluster.
- Utilisez la commande
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 quemy-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 surboot: 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 console VM_NAME
Lorsque vous y êtes invité, saisissez les identifiants utilisateur que vous avez spécifiés pour créer la VM.
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 quemy-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 de10Gi
(10 gibioctets).STORAGE_CLASS_NAME
:StorageClass
que vous souhaitez utiliser pour votreVirtualMachineDisk
.- Utilisez la commande
kubectl get storageclass
pour regrouper les éléments disponibles dans votre cluster.
- Utilisez la commande
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 sectionspec.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.