Gérer les machines virtuelles sur les serveurs connectés Distributed Cloud

Cette page explique comment gérer les machines virtuelles sur les serveurs Google Distributed Cloud connectés exécutant VM Runtime sur Google Distributed Cloud. Avant de suivre les étapes de cette page, vous devez connaître VM Runtime sur GDC. Pour obtenir la liste des systèmes d'exploitation invités compatibles, consultez Systèmes d'exploitation invités validés pour l'environnement d'exécution de VM sur GDC.

Pour découvrir comment les machines virtuelles constituent un élément essentiel de la plate-forme connectée Distributed Cloud, consultez Étendre GKE Enterprise pour gérer les VM périphériques sur site.

Les clusters connectés Distributed Cloud sont compatibles avec les Webhooks de machine virtuelle. Cela permet à Distributed Cloud Connected de valider les requêtes utilisateur envoyées au serveur d'API Kubernetes local. Les demandes refusées génèrent des informations détaillées sur le motif du refus.

Configurer le stockage Symcloud

Les serveurs Google Distributed Cloud Connected utilisent Rakuten Symcloud Storage comme solution de stockage. Symcloud Storage est une solution tierce qui sert de couche d'abstraction du stockage local sur chaque nœud connecté à Distributed Cloud et met son stockage local à la disposition des charges de travail s'exécutant sur d'autres nœuds connectés à Distributed Cloud.

Symcloud Storage est déployé depuis Google Cloud Marketplace et est soumis aux conditions qui y sont indiquées. Google fournit une assistance limitée pour l'utilisation de Symcloud Storage avec Distributed Cloud Connected et peut faire appel au fournisseur tiers pour obtenir de l'aide. Les mises à jour logicielles de Symcloud Storage sont incluses dans les mises à jour logicielles connectées Distributed Cloud.

Configurez votre cluster connecté Google Distributed Cloud comme suit pour activer Symcloud Storage pour les machines virtuelles :

1. Créez l'espace de noms robinio à l'aide de la commande suivante :

   kubectl create ns robinio
   

2. Obtenez le fichier de licence Symcloud Storage et appliquez-le au cluster à l'aide de la commande suivante :

   kubectl apply LICENSE_FILE
   

3. Vérifiez que Symcloud Storage est opérationnel à l'aide de la commande suivante :

   kubectl apply LICENSE_FILE
   

   La commande renvoie un résultat semblable à celui-ci :

    Name:         robin
    Namespace:
    Labels:       app.kubernetes.io/instance=robin
                  app.kubernetes.io/managed-by=robin.io
                  app.kubernetes.io/name=robin
    Annotations:  <none>
    API Version:  manage.robin.io/v1
    Kind:         RobinCluster
    Metadata:
      …
    Spec:
      …
    Status:
      …
      Phase:             Ready
      …
   

4. Créez la classe de stockage robin-block-immediate en appliquant la configuration suivante au cluster :

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: robin-block-immediate
   parameters:
     faultdomain: host
     replication: "3"
     blocksize:   "512"
   provisioner: robin
   reclaimPolicy: Delete
   volumeBindingMode: Immediate
   allowVolumeExpansion: true
   

5. Créez la classe d'instantanés de volume robin-snapshotclass en appliquant la configuration suivante au cluster :

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotClass
   metadata:
     name: robin-snapshotclass
     labels:
       app.kubernetes.io/instance: robin
       app.kubernetes.io/managed-by: robin.io
       app.kubernetes.io/name: robin
     annotations:
       snapshot.storage.kubernetes.io/is-default-class: "true"
   driver: robin
   deletionPolicy: Delete
   

Activer la compatibilité avec l'environnement d'exécution de VM sur GDC sur Distributed Cloud connecté

Par défaut, la compatibilité avec les machines virtuelles de l'environnement d'exécution de VM sur GDC est désactivée sur Distributed Cloud Connected. Pour l'activer, suivez les étapes décrites dans cette section. Les instructions de cette section supposent que vous disposez d'un cluster Distributed Cloud connecté entièrement fonctionnel.

Pour activer le sous-système de machine virtuelle VM Runtime sur GDC, procédez comme suit :

1. Modifiez la ressource personnalisée VMRuntime avec le contenu suivant et appliquez-la à votre cluster :

   apiVersion: vm.cluster.gke.io/v1
   kind: VMRuntime
   metadata:
     annotations:
       baremetal.cluster.gke.io/vmrumtime-force-disable: "false"
       vm.cluster.gke.io/enable-vm-backup: "true"
   spec:
     enabled: true
     storage:
       defaultStorageClass: robin-block-immediate
   haPolicy:
     defaultRecoveryStrategy: Reschedule
     nodeHeartbeatInterval: 15s
     nodeMonitorGracePeriod: 55s

   Cette opération prend généralement plusieurs minutes.

2. Exécutez la commande suivante pour vérifier que la ressource personnalisée VMRuntime a été appliquée à votre cluster :

   kubectl get vmruntime
   

   La commande renvoie un résultat semblable à l'exemple suivant :

   NAME        AGE   ENABLED   READY   PREFLIGHTCHECK
   vmruntime   5m   true      true    true
   

3. Modifiez le storageprofile pour la classe de stockage robin-block-immediate avec le contenu suivant et appliquez-le à votre cluster :

   apiVersion: cdi.kubevirt.io/v1beta1
   kind: StorageProfile
   metadata:
     name: robin-block-immediate
   spec:
     claimPropertySets:
       accessModes:
         ReadWriteMany
     volumeMode: Block

Installer l'outil de gestion virtctl

Vous avez besoin de l'outil client virtctl pour gérer les machines virtuelles sur votre cluster connecté Distributed Cloud. Pour installer l'outil, procédez comme suit :

1. Installer l'outil de client virtctl en tant que plug-in kubectl :

   export VERSION=v0.59.0-anthos1.28-gke.8
   gcloud storage cp gs://anthos-baremetal-release/virtctl/${VERSION}/linux-amd64/virtctl/usr/local/bin/virtctl
   cd /usr/local/bin
   sudo ln -s virtctl kubectl-virt
   sudo chmod a+x virtctl
   cd -

2. Vérifiez que le plug-in virt est installé :

   kubectl plugin list

   Si le plug-in a été installé, le résultat de la commande liste kubectl-virt comme l'un des plug-ins.

Créer un bucket Cloud Storage pour les images de machine virtuelle

Suivez les étapes de cette section pour créer un bucket Cloud Storage pour vos images de machine virtuelle. Si vous disposez déjà d'un dépôt d'images établi, ignorez cette section.

1. Suivez la procédure décrite dans Créer des buckets pour créer un bucket.

2. Configurez un compte de service et une clé pour accéder au bucket à l'aide des commandes suivantes :

   export PROJECT_ID=$(gcloud config get-value project)
   gcloud iam service-accounts create image-access
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:image-access@${PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/storage.objectViewer" \
   gcloud iam service-accounts keys create ./image-access-gcr.json \
     --iam-account="image-access@${PROJECT_ID}.iam.gserviceaccount.com"

3. Créez un secret dans le cluster pour accéder au bucket. Si votre bucket est public, ignorez cette étape. Ce secret doit exister dans le même espace de noms que les disques de votre machine virtuelle. Vous devez créer un secret dans chaque espace de noms concerné.

   kubectl create secret generic gcs-image-sa --from-file=creds-gcp.json=./image-access-gcr.json -n NAMESPACE

   Remplacez CLUSTER_ID par le nom de l'espace de noms cible.

4. Stockez vos images dans le bucket.

Créer un disque de machine virtuelle à partir d'une image de machine virtuelle

Suivez les étapes de cette section pour créer un disque de machine virtuelle à partir d'une image de machine virtuelle.

Créer un disque à partir d'une image stockée dans Cloud Storage

Créez un disque de machine virtuelle à partir d'une machine virtuelle stockée dans votre bucket Cloud Storage en appliquant la configuration suivante à votre cluster :

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   source:
     gcs:
       url: gs://{PROJECT_ID}-vm-images/IMAGE_FILE
       secretRef: gcs-image-sa
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Remplacez les éléments suivants :

• DISK_NAME : nom de ce disque de machine virtuelle.
• NAMESPACE : espace de noms cible.
• IMAGE_FILE : nom du fichier image de la machine virtuelle.
• DISK_SIZE : taille de disque souhaitée. Cette valeur doit être supérieure à la valeur virtual-size du fichier image de la machine virtuelle. Vous pouvez trouver cette valeur avec la commande qemu-img info DISK_SIZE.

Si vous ne spécifiez pas de valeur storageClassName, la valeur par défaut spécifiée dans la ressource VMRuntime est utilisée.

Créer un disque à partir d'une image de disque existante

Créez un disque de machine virtuelle à partir d'un disque ou d'un fichier image de machine virtuelle existant sur votre cluster comme suit.

1. Créez le disque cible en appliquant la configuration suivante à votre cluster :

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachineDisk
   metadata:
     name: IMAGE_DISK_NAME
     namespace: NAMESPACE
   spec:
     source:
       virtualMachineDisk:
         name: EXISTING_DISK_NAME
     size: DISK_SIZE
     storageClassName: robin-block-immediate

   Remplacez les éléments suivants :

   • IMAGE_DISK_NAME : nom de ce disque de machine virtuelle.
   • NAMESPACE : espace de noms cible.
   • EXISTING_DISK_NAME : nom du disque de machine virtuelle existant.
   • DISK_SIZE : taille de disque souhaitée. Cette taille doit être supérieure ou égale à celle du fichier image ou du disque existant.

   Vous pouvez obtenir la taille de votre disque ou fichier image existant à l'aide de l'outil qemu-img comme suit :

   qemu-img info EXISTING_DISK_NAME

   Si vous ne spécifiez pas de valeur storageClassName, la valeur par défaut spécifiée dans la ressource VMRuntime est utilisée.

2. Créez un disque à partir de votre fichier image existant en appliquant la configuration suivante à votre cluster :

   apiVersion: vm.cluster.gke.io/v1
   kind: VirtualMachineDisk
   metadata:
     name: DISK_NAME
     namespace: NAMESPACE
   spec:
     source:
       virtualMachineDisk:
         name: IMAGE_DISK_NAME
     size: DISK_SIZE
     storageClassName: robin-block-immediate

   Remplacez les éléments suivants :

   • IMAGE_DISK_NAME : nom du disque de la machine virtuelle que vous avez créé à l'étape précédente.
   • NAMESPACE : espace de noms cible.
   • DISK_SIZE : taille de disque souhaitée. Doit être égale à la taille du disque de la machine virtuelle que vous avez créé à l'étape précédente.

3. Redimensionnez le disque cible à la taille souhaitée à l'aide de la commande suivante :

   kubectl edit gdisk DISK_NAME -n NAMESPACE

   Remplacez les éléments suivants :

   • DISK_NAME : nom du disque de la machine virtuelle que vous avez créé à l'étape précédente.
   • NAMESPACE : espace de noms cible.

4. Modifiez la valeur spec.size dans la configuration du disque et appliquez-la à votre cluster.

Créer un disque vide

Créez un disque de machine virtuelle vide en appliquant la configuration suivante à votre cluster :

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Remplacez les éléments suivants :

• DISK_NAME : nom de ce disque de machine virtuelle.
• NAMESPACE : espace de noms cible.
• DISK_SIZE : taille souhaitée du disque en gibioctets. Cette valeur doit être supérieure à la valeur virtual-size du fichier image de la machine virtuelle. Vous pouvez trouver cette valeur avec la commande qemu-img info DISK_SIZE.

Si vous ne spécifiez pas de valeur storageClassName, la valeur par défaut spécifiée dans la ressource VMRuntime est utilisée.

Configurer la mise en réseau virtuelle

Suivez la procédure décrite dans Mise en réseau pour configurer la mise en réseau virtuelle de vos machines virtuelles.

Créer une machine virtuelle

Suivez les étapes de cette section pour créer une machine virtuelle sur votre déploiement de serveur connecté Distributed Cloud. Les instructions de cette section sont des exemples destinés à illustrer des configurations pour différents scénarios. Pour en savoir plus sur la configuration des machines virtuelles, consultez Créer une VM avec des ressources de processeur et de mémoire spécifiques en utilisant l'environnement d'exécution des VM sur GDC.

Créer une machine virtuelle à partir d'une image disque bootable

Pour créer une machine virtuelle à partir d'une image de disque bootable, appliquez la configuration suivante à votre cluster :

 kind: VirtualMachine
 metadata:
   name: my-virtual-machine
   namespace: my-vm-namespace
 spec:
   osType: Linux/Windows
   guestEnvironment: {} // comment out this line to enable guest environment for access management
   autoRestartOnConfigurationChange: true 
   compute:
     cpu:
       vcpus: 6
     memory:
       capacity: 8Gi
   interfaces:
      - name: eth0
        networkName: network-410
        ipAddresses:
        - 10.223.237.10/25
   disks:
     - virtualMachineDiskName: my-boot-disk
       boot: true
     - virtualMachineDiskName: my-data-disk

Remplacez les éléments suivants :

• DISK_NAME : nom de ce disque de machine virtuelle.
• NAMESPACE : espace de noms cible.

Créer une machine virtuelle à partir d'une image de disque optique ISO

Pour créer une machine virtuelle à partir d'une image de disque optique ISO, suivez les étapes décrites dans Créer une VM Windows à partir d'une image ISO dans Google Distributed Cloud.

Créer une machine virtuelle compatible avec les GPU

Suivez les étapes décrites sur cette page pour créer une machine virtuelle configurée en fonction des besoins de votre entreprise, puis suivez les étapes décrites dans Configurer une machine virtuelle pour utiliser des ressources GPU.

Accéder à une machine virtuelle

Suivez les étapes de cette section pour accéder à une machine virtuelle exécutée sur votre déploiement de serveur connecté Distributed Cloud.

Obtenir des identifiants d'accès

Suivez les étapes de cette section pour obtenir les identifiants nécessaires pour accéder à votre machine virtuelle à l'aide de la fonctionnalité d'environnement invité Linux.

1. Activez l'environnement invité Linux pour la machine virtuelle cible en appliquant la configuration suivante à votre cluster :

   kind: VirtualMachine
   metadata:
    name: my-virtual-machine
    namespace: my-vm-namespace
   spec:
    osType: Linux
    guestEnvironment: {}
    autoRestartOnConfigurationChange: true 

2. Générez un fichier id_rsa.pub contenant une paire de clés SSH à l'aide de la commande suivante :

   ssh-keygen -t rsa

3. Créez une ressource VirtualMachineAccessRequest en appliquant la configuration suivante à votre cluster :

   apiVersion: vm.cluster.gke.io/v1alpha1
   kind: VirtualMachineAccessRequest
   metadata:
    name: RESOURCE_NAME
    namespace: NAMESPACE
   spec:
     vm: VM_NAME
     user: USER_NAME
     ssh:
       key: RSA_KEY
       ttl: 2h

Remplacez les éléments suivants :

• RESOURCE_NAME : nom descriptif de cette ressource de demande d'accès à la machine virtuelle.
• NAMESPACE : espace de noms cible.
• VM_NAME : nom de la machine virtuelle cible.
• USER_NAME : nom de l'utilisateur auquel l'accès est accordé.
• RSA_KEY : contenu du fichier id_rsa.pub que vous avez généré à l'étape précédente.

1. Vérifiez l'état de la demande d'accès à l'aide de la commande suivante :

   kubectl get vmar
   

   Lorsque la commande renvoie un état Configured, passez à l'étape suivante.

2. Accédez à la machine virtuelle avec SSH ou le Bureau à distance :

   • Si la machine virtuelle est connectée à votre réseau local, vous pouvez y accéder directement.
   • Si la machine virtuelle est connectée au réseau de pods, vous devez créer un service d'équilibreur de charge pour accéder aux ports requis.

Démarrer, redémarrer ou arrêter une machine virtuelle

Utilisez les commandes suivantes pour démarrer, redémarrer ou arrêter une machine virtuelle :

• Démarrer une machine virtuelle : kubectl virt start vmVM_NAME-nNAMESPACE
• Redémarrer une machine virtuelle : kubectl virt restart vmVM_NAME-nNAMESPACE
• Arrêter une machine virtuelle : kubectl virt stop vmVM_NAME-nNAMESPACE

Remplacez les éléments suivants :

• VM_NAME : nom de la machine virtuelle cible.
• NAMESPACE : espace de noms cible.

Étapes suivantes

• Gérer les machines virtuelles sur les racks Distributed Cloud connectés
• Déployer des charges de travail sur Distributed Cloud connecté
• Gérer les charges de travail GPU
• Gérer les zones
• Gérer les machines
• Gérer les clusters
• Gérer les pools de nœuds