Gérer les machines virtuelles

Cette page explique comment gérer les machines virtuelles sur votre déploiement Google Distributed Cloud connecté 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

Google Distributed Cloud Connected utilise 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 Google Distributed Cloud connecté comme suit pour activer Symcloud Storage pour les machines virtuelles. Pour en savoir plus, consultez Installer Symcloud Storage sur un nœud connecté Distributed Cloud.

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

    kubectl create ns robin-admin

  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 describe robincluster

    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

  6. 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=GDC_SO_VERSION
gcloud storage cp gs://anthos-baremetal-release/virtctl/${VERSION}/linux-amd64/virtctl ./virtctl
sudo mv ./virtctl /usr/local/bin/virtctl
cd /usr/local/bin
sudo ln -s virtctl kubectl-virt
sudo chmod a+x virtctl
cd -

    Remplacez GDC_SO_VERSION par la version cible de Distributed Cloud software-only.

  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 VM

Suivez les étapes de cette section pour créer un bucket Cloud Storage pour vos images de machine virtuelle. Le bucket utilise Workload Identity Federation pour associer un compte de service Kubernetes au compte de service Google Cloud correspondant afin d'accéder au bucket. En d'autres termes, le compte de service Kubernetes emprunte l'identité du compte de service Google Cloud. Si vous disposez déjà d'un dépôt d'images établi, ignorez cette section.

Pour réduire le risque d'identité identique dans un parc multicluster, suivez les consignes décrites dans les bonnes pratiques concernant la fédération d'identité de charge de travail pour un parc lorsque vous effectuez les étapes de cette section.

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

  2. Créez un compte de service Google Cloud pour accéder au bucket :

    export GSA_PROJECT_ID=GSA_PROJECT_ID
export GSA_NAME=GSA_NAME
gcloud iam service-accounts create ${GSA_NAME}

    Remplacez les éléments suivants :

    • GSA_NAME : nom explicite pour ce compte de service Google Cloud .
    • GSA_PROJECT_ID : ID du projet Google Cloud qui héberge le compte de serviceGoogle Cloud cible.

  3. Accordez au compte de service Google Cloud les autorisations d'accès au bucket :

    export BUCKET_PROJECT_ID=BUCKET_PROJECT_ID
export GSA_NAME=GSA_NAME
gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
   --member="serviceAccount:${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/storage.objectViewer" \
   --project=${BUCKET_PROJECT_ID}

    Remplacez les éléments suivants :

    • GSA_NAME : nom du compte de service Google Cloud cible.
    • BUCKET_PROJECT_ID : ID du projet Google Cloud qui héberge le bucket.
    • GSA_PROJECT_ID : ID du projet Google Cloud qui héberge le compte de serviceGoogle Cloud cible.

  4. Créez un compte de service Kubernetes dans l'espace de noms de la machine virtuelle cible pour l'associer à votre compte de service Google Cloud  :

    export GSA_PROJECT_ID=GSA_PROJECT_ID
export VM_NAMESPACE=NAMESPACE
export KSA_NAME=KSA_NAME
export GSA_EMAIL=${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com
kubectl create serviceaccount ${KSA_NAME} -n ${VM_NAMESPACE}
kubectl annotate serviceaccount ${KSA_NAME} gsaEmail=${GSA_EMAIL} -n ${VM_NAMESPACE}

    Remplacez les éléments suivants :

    • GSA_PROJECT_ID : ID du projet Google Cloud qui héberge le compte de serviceGoogle Cloud cible.
    • NAMESPACE : espace de noms de la machine virtuelle cible.
    • KSA_NAME : nom explicite pour ce compte de service Kubernetes.
    • GSA_NAME : nom du compte de service Google Cloud correspondant.

  5. Recherchez le nom du pool d'identités de charge de travail et du fournisseur d'identité de votre cluster :

    gcloud container fleet memberships describe MEMBERSHIP_ID \
    --project=FLEET_PROJECT_ID \
    --format="table(authority.identityProvider,authority.workloadIdentityPool,name)"

    Remplacez les éléments suivants :

    • MEMBERSHIP_ID : nom de l'appartenance du cluster au parc. Il s'agit généralement du nom de votre cluster.
    • FLEET_PROJECT_ID : ID du projet hôte Google Cloud du parc.

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

    IDENTITY_PROVIDER: IDENTITY_PROVIDER
WORKLOAD_IDENTITY_POOL: WORKLOAD_IDENTITY_POOL

    Dans le résultat, notez les valeurs suivantes :

  6. Associez le compte de service Kubernetes au compte de service Google Cloud pour configurer l'emprunt d'identité :

    export GSA_PROJECT_ID=GSA_PROJECT_ID
export GSA_NAME=GSA_NAME
export KSA_NAME=KSA_NAME
export VM_NAMESPACE=NAMESPACE
export WI_POOL=WORKLOAD_IDENTITY_POOL
gcloud iam service-accounts add-iam-policy-binding ${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com \
   --project=${GSA_PROJECT_ID} \
   --role=roles/iam.workloadIdentityUser \
   --member="serviceAccount:${WI_POOL}[${VM_NAMESPACE}/${KSA_NAME}]"
   --condition="IAM_CONDITION"
   --condition-from-file="IAM_CONDITION_FILE"

    Remplacez les éléments suivants :

    • GSA_PROJECT_ID : ID du projet Google Cloud qui héberge le compte de serviceGoogle Cloud cible.
    • GSA_NAME : nom du compte de service Google Cloud correspondant.
    • KSA_NAME : nom du compte de service Kubernetes cible.
    • NAMESPACE : espace de noms de la machine virtuelle cible.
    • WORKLOAD_IDENTITY_POOL : nom du pool d'identités de charge de travail de votre cluster.
    • IAM_CONDITION : facultatif, spécifie les conditions IAM à utiliser pour limiter l'accès à des clusters spécifiques du parc. Si elle est omise ou définie sur None, aucune condition IAM ne s'applique.
    • IAM_CONDITION_FILE : facultatif. Spécifie le fichier contenant les conditions IAM à utiliser pour limiter l'accès à des clusters spécifiques du parc. Si elle est omise, aucune condition IAM ne s'applique, sauf si l'indicateur --condition est spécifié et défini sur une valeur autre que None.

  7. Stockez vos images dans le bucket.

Vous pouvez également utiliser l'ancienne méthode avec un secret généré à partir de la clé active de votre compte de service Google. Pour en savoir plus, consultez Créer un bucket Cloud Storage pour les images de VM.

Restreindre l'accès au bucket avec des conditions IAM

Les conditions IAM vous permettent de spécifier les clusters du parc qui peuvent accéder au bucket. Si aucune condition IAM n'est spécifiée, tous les clusters du parc ayant le même compte de service Kubernetes dans le même espace de noms peuvent accéder au bucket, ce qui présente un risque d'uniformité des identités. Si vous ne spécifiez pas de conditions IAM, vous pouvez également revenir à l'ancien mécanisme d'accès qui utilise un secret généré à partir de la clé active d'un compte de service Google. Voici un exemple de configuration et d'application des conditions IAM pour limiter l'accès à votre bucket :

  1. Créez le fichier de condition IAM :

    cat <<EOF > iam_condition.yaml
> expression: request.auth.claims.google.providerId == '$IDENTITY_PROVIDER'
title: allow_only_this_cluster
> EOF

  2. Appliquez le fichier de conditions IAM lorsque vous associez le GSA au KSA. Exécutez la commande suivante dans votre projet GSA Google Cloud  :

    gcloud iam service-accounts add-iam-policy-binding "${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com" \
  --project="${GSA_PROJECT_ID}" \
  --role=roles/iam.workloadIdentityUser \
  --member="serviceAccount:${WI_POOL}[${VM_NAMESPACE}/${KSA_NAME}]" \
  --condition-from-file=iam_condition.yaml

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://${BUCKET_PROJECT_ID}-vm-images/IMAGE_FILE_PATH
       serviceAccount: KSA_NAME
   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 de la machine virtuelle cible.
  • IMAGE_FILE_PATH : chemin d'accès complet et nom du fichier image de la machine virtuelle. Pour obtenir ce chemin d'accès, effectuez un clic droit sur l'image dans la console Google Cloud , puis sélectionnez Copier l'URI gsutil.
  • KSA_NAME : compte de service Kubernetes pour télécharger les images de machine virtuelle que vous avez créées précédemment.
  • DISK_SIZE : taille cible du disque. 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 stockée sur un service tiers

Vous pouvez également utiliser http, https, S3 ou un registre d'images pour stocker vos images de machines virtuelles. Si votre service de stockage nécessite des identifiants pour l'accès, convertissez-les en secret et spécifiez-le à l'aide du champ secretRef. Exemple :

source:
    http/s3/registry:
       url: 
       secretRef: "SECRET_NAME" # optional

Remplacez SECRET_NAME par le nom de votre secret.

Pour en savoir plus, consultez Source HTTP/S3/GCS/Registry.

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 à l'aide de la console Google Cloud

Pour créer une machine virtuelle à l'aide de la console Google Cloud , procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page Clusters.

    accéder aux clusters

  2. Sélectionnez le projet cible Google Cloud .

  3. (Facultatif) Si ce n'est pas déjà fait, connectez-vous au cluster cible :

    1. Dans le volet de navigation de gauche, cliquez sur Clusters.

    2. Dans la liste Clusters gérés par Anthos, cliquez sur le cluster cible.

    3. Dans le volet d'informations à droite, cliquez sur SE CONNECTER.

    4. Dans la boîte de dialogue pop-up qui s'affiche, sélectionnez votre méthode d'authentification préférée, saisissez vos identifiants, puis cliquez sur SE CONNECTER.

  4. Accédez à la page Machines virtuelles.

    Accéder à Virtual Machines

  5. Cliquez sur CRÉER.

  6. Dans la section Informations de base, procédez comme suit :

    1. Dans le champ Nom, saisissez un nom explicite pour la machine virtuelle.

    2. Dans le champ Sélectionner un cluster, sélectionnez le cluster cible pour la machine virtuelle.

    3. Dans le champ Espace de noms, sélectionnez l'espace de noms cible.

    4. Dans le champ Type d'OS, sélectionnez le système d'exploitation cible.

    5. (Facultatif) Si vous souhaitez ajouter un ou plusieurs libellés à la configuration de cette machine virtuelle, cliquez sur AJOUTER UN LIBELLÉ.

  7. Dans la section Configuration de la machine, effectuez l'une des opérations suivantes :

    • Si vous souhaitez spécifier le nombre de processeurs virtuels et la quantité de mémoire pour cette machine virtuelle, sélectionnez Configuration personnalisée, saisissez les valeurs cibles, puis cliquez sur SUIVANT.

    • Si vous souhaitez utiliser un nombre prédéterminé de processeurs virtuels et une quantité de mémoire pour cette machine virtuelle, sélectionnez Configuration standard, puis une configuration de machine dans la liste déroulante Type de machine, puis cliquez sur SUIVANT.

  8. Dans la section Stockage, effectuez l'une des opérations suivantes :

    • Si vous souhaitez créer un disque virtuel pour cette machine virtuelle, sélectionnez Ajouter un disque, puis saisissez un nom explicite dans le champ Nom, une taille en gigaoctets dans le champ Go et une URL dans le champ Image.

    • Si vous souhaitez utiliser un disque virtuel existant pour cette machine virtuelle, sélectionnez Sélectionner un disque existant, puis sélectionnez l'image de disque cible dans la liste déroulante Sélectionner un disque.

    • Indiquez si vous souhaitez que le disque soit en lecture seule et s'il sera automatiquement supprimé lorsque cette machine virtuelle sera supprimée à l'aide des cases à cocher Lecture seule et Suppression automatique.

    • Spécifiez un pilote de disque virtuel dans la liste déroulante Pilote.

    • Pour ajouter un autre disque à cette machine virtuelle, cliquez sur AJOUTER UN DISQUE dans la section Disques supplémentaires.

    • Cliquez sur SUIVANT.

  9. Dans la section Réseau, procédez comme suit :

    1. Dans la sous-section Interface réseau par défaut, spécifiez le nom de l'interface réseau principale de cette machine virtuelle dans le champ Nom de l'interface.

    2. Sélectionnez le type de réseau correspondant dans la liste déroulante Type de réseau.

    3. Indiquez si vous souhaitez autoriser l'accès externe à cette interface réseau à l'aide de la case à cocher Autoriser l'accès externe. Si vous activez cette option, vous devez saisir une liste de ports à exposer en externe, séparés par une virgule, dans le champ Ports exposés.

    4. Si vous souhaitez ajouter une ou plusieurs interfaces réseau secondaires à cette machine virtuelle, cliquez sur AJOUTER UNE INTERFACE RÉSEAU.

    5. Cliquez sur SUIVANT.

  10. Dans la section Options avancées, cochez la case Redémarrage automatique lors de la mise à jour pour indiquer si cette machine virtuelle doit redémarrer une fois que le logiciel connecté Distributed Cloud sur le cluster cible a été mis à jour.

  11. Dans la section Firmware, procédez comme suit :

    1. Sélectionnez le type de micrologiciel cible dans le champ Type de bootloader. Si vous sélectionnez le micrologiciel UEFI, vous pouvez activer le démarrage sécurisé en cochant la case Démarrage sécurisé.

    2. Spécifiez un numéro de série pour cette machine virtuelle dans le champ Numéro de série.

    3. Spécifiez un identifiant unique universel (UUID) pour cette machine virtuelle dans le champ UUID.

  12. Dans la section Cloud-init, procédez comme suit :

    • Spécifiez une valeur de secret des données réseau dans le champ Secret des données réseau.

    • Spécifiez une valeur secrète pour les données utilisateur dans le champ Secret des données utilisateur.

  13. Cliquez sur CRÉER UNE VM pour créer la machine virtuelle.

Créer une machine virtuelle à partir d'un fichier YAML

Pour créer une machine virtuelle à partir d'un fichier de configuration YAML, procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page Clusters.

    accéder aux clusters

  2. Sélectionnez le projet cible Google Cloud .

  3. (Facultatif) Si ce n'est pas déjà fait, connectez-vous au cluster cible :

    1. Dans le volet de navigation de gauche, cliquez sur Clusters.

    2. Dans la liste Clusters gérés par Anthos, cliquez sur le cluster cible.

    3. Dans le volet d'informations à droite, cliquez sur SE CONNECTER.

    4. Dans la boîte de dialogue pop-up qui s'affiche, sélectionnez votre méthode d'authentification préférée, saisissez vos identifiants, puis cliquez sur SE CONNECTER.

  4. Accédez à la page Machines virtuelles.

    Accéder à Virtual Machines

  5. Cliquez sur CRÉER AVEC YAML.

  6. Dans le champ Sélectionner un cluster, sélectionnez le cluster cible pour la machine virtuelle.

  7. Collez la configuration de la machine virtuelle au format YAML dans le champ YAML.

  8. Cliquez sur CRÉER.

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

Si vous ne disposez pas encore d'identifiants pour accéder à la machine virtuelle, suivez les étapes de cette section pour les obtenir à 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: // enabled by default; disable with guestEnvironment: {}
   accessManagement:
    enable: 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.

Démarrer ou arrêter une machine virtuelle à l'aide de la console Google Cloud

  1. Dans la console Google Cloud , accédez à la page Clusters.

    accéder aux clusters

  2. Sélectionnez le projet cible Google Cloud .

  3. (Facultatif) Si ce n'est pas déjà fait, connectez-vous au cluster cible :

    1. Dans le volet de navigation de gauche, cliquez sur Clusters.

    2. Dans la liste Clusters gérés par Anthos, cliquez sur le cluster cible.

    3. Dans le volet d'informations à droite, cliquez sur SE CONNECTER.

    4. Dans la boîte de dialogue qui s'affiche, sélectionnez votre méthode d'authentification préférée, saisissez vos identifiants, puis cliquez sur SE CONNECTER.

  4. Accédez à la page Machines virtuelles.

    Accéder à Virtual Machines

  5. Dans la liste des machines virtuelles, cochez la ou les cases correspondant aux machines virtuelles cibles.

  6. En haut de la page, cliquez sur DÉMARRER ou ARRÊTER, selon le cas.

Afficher l'état d'une machine virtuelle à l'aide de la console Google Cloud

  1. Dans la console Google Cloud , accédez à la page Clusters.

    accéder aux clusters

  2. Sélectionnez le projet cible Google Cloud .

  3. (Facultatif) Si ce n'est pas déjà fait, connectez-vous au cluster cible :

    1. Dans le volet de navigation de gauche, cliquez sur Clusters.

    2. Dans la liste Clusters gérés par Anthos, cliquez sur le cluster cible.

    3. Dans le volet d'informations à droite, cliquez sur SE CONNECTER.

    4. Dans la boîte de dialogue pop-up qui s'affiche, sélectionnez votre méthode d'authentification préférée, saisissez vos identifiants, puis cliquez sur SE CONNECTER.

  4. Accédez à la page Machines virtuelles.

    Accéder à Virtual Machines

  5. Cliquez sur la machine virtuelle cible.

  6. Sur la page qui s'affiche, cliquez sur les onglets Détails, Événements et YAML pour afficher les informations correspondantes sur cette machine virtuelle.

Modifier une machine virtuelle

Pour modifier une machine virtuelle, vous devez la supprimer et la recréer avec la configuration mise à jour.

Supprimer une machine virtuelle à l'aide de la console Google Cloud

  1. Dans la console Google Cloud , accédez à la page Clusters.

    accéder aux clusters

  2. Sélectionnez le projet cible Google Cloud .

  3. (Facultatif) Si ce n'est pas déjà fait, connectez-vous au cluster cible :

    1. Dans le volet de navigation de gauche, cliquez sur Clusters.

    2. Dans la liste Clusters gérés par Anthos, cliquez sur le cluster cible.

    3. Dans le volet d'informations à droite, cliquez sur SE CONNECTER.

    4. Dans la boîte de dialogue qui s'affiche, sélectionnez votre méthode d'authentification préférée, saisissez vos identifiants, puis cliquez sur SE CONNECTER.

  4. Accédez à la page Machines virtuelles.

    Accéder à Virtual Machines

  5. Dans la liste des machines virtuelles, cochez la case de la machine virtuelle cible.

  6. En haut de la page, cliquez sur SUPPRIMER.

  7. Dans la boîte de dialogue de confirmation qui s'affiche, saisissez le nom de la machine virtuelle, puis cliquez sur SUPPRIMER.

Sauvegarder une machine virtuelle

Cette section explique comment configurer votre environnement pour sauvegarder vos charges de travail de machine virtuelle et comment gérer vos sauvegardes. Pour activer cette fonctionnalité, contactez votre représentant Google.

Prérequis

  1. Si vous ne l'avez pas encore fait, créez la ressource personnalisée robin-block-immediate de type StorageClass avec le contenu suivant et appliquez-la à votre cluster :

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

  2. Si vous ne l'avez pas encore fait, créez une ressource personnalisée robin-snapshotclass de type VolumeSnapshotClass avec le contenu suivant et appliquez-la à votre 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

Créer un dépôt de sauvegarde en ligne

Un dépôt de sauvegarde en ligne est un emplacement de stockage en ligne compatible avec S3 pour vos sauvegardes de machines virtuelles. Il stocke également les enregistrements des sauvegardes, des plans de sauvegarde et des plans de restauration, et sert de destination pour la restauration des sauvegardes de machines virtuelles.

Pour créer un dépôt de sauvegarde en ligne pour vos machines virtuelles, procédez comme suit :

  1. Créez un bucket Cloud Storage comme décrit dans Créer des buckets.

  2. Créez 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)
export SVC_ACCOUNT=backup-access
gcloud iam service-accounts create $SVC_ACCOUNT
gcloud projects add-iam-policy-binding $PROJECT_ID \ 
   --member="serviceAccount:${SVC_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/backupdr.cloudStorageOperator"
gcloud storage hmac create  ${SVC_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com > hmac_temp_key_file
awk 'NR==1{print "ACCESS_ID=" $NF} NR==2{print "SECRET=" $NF}' < hmac_temp_key_file > hmac_key_file

  3. Configurez le secret pour accéder au bucket de sauvegarde à l'aide des commandes suivantes :

    source ./hmac_key_file
kubectl create secret generic SECRET_NAME \
   --from-literal=access-key=$SECRET \
   --from-literal=access-key-id=$ACCESS_ID -n NAMESPACE

    Remplacez les éléments suivants :

    • SECRET_NAME : nom descriptif de ce secret.
    • NAMESPACE : espace de noms cible.

  4. Créez la ressource BackupRepository en appliquant la configuration suivante à votre cluster :

    apiVersion: backup.gdc.goog/v1
kind: BackupRepository
metadata:
  name: "REPOSITORY_NAME"
spec:
  secretReference:
    namespace: NAMESPACE
    name: gcs-hmac-secret
  endpoint: "https://storage.googleapis.com"
  type: "S3"
  s3Options:
    bucket: "BUCKET_NAME"
    region: "REGION"
    forcePathStyle: true
  importPolicy: "ReadWrite"
# Force attachment for convenience.
force: true

    Remplacez les éléments suivants :

    • REPOSITORY_NAME : nom descriptif du dépôt.
    • BUCKET_NAME : nom du bucket de sauvegarde.
    • NAMESPACE : espace de noms cible.
    • REGION : région Google Cloud dans laquelle le cluster Distributed Cloud cible a été créé.

  5. Vérifiez que le cluster peut accéder au dépôt de sauvegarde à l'aide de la commande suivante :

    kubectl get BackupRepository

Créer un dépôt de sauvegarde local

Un dépôt de sauvegarde local est un emplacement de stockage compatible avec S3 pour vos sauvegardes de machines virtuelles, qui réside localement sur votre cluster connecté Distributed Cloud. Un dépôt de sauvegarde local est fonctionnellement identique à un dépôt de sauvegarde en ligne.

  1. Générez une clé de chiffrement AES256 à utiliser pour le chiffrement de la configuration au niveau de l'application :

    openssl rand -base64 32

    La commande génère une clé aléatoire de 256 bits encodée en base64. Exemple :

    aBcD_eFgH1iJkLmN0pQrStUvWxFyZgAhIjKlMnOpQ=

  2. Double-encodez la clé à utiliser comme charge utile dans la configuration YAML de la ressource BackupRepository :

    echo -n "AES_KEY" | base64

    Remplacez AES_KEY par la clé AES256 encodée en base64 que vous avez générée à l'étape précédente. Stockez cette clé dans un fichier local.

  3. Configurez le secret pour accéder au dépôt de sauvegarde à l'aide des commandes suivantes :

    kubectl create secret generic SECRET_NAME \
   --from-literal=access-key=ENCODED_AES_KEY \
   --namespace NAMESPACE

    Remplacez les éléments suivants :

    • ENCODED_AES_KEY : clé AES256 à double encodage que vous avez générée à l'étape précédente.
    • SECRET_NAME : nom descriptif de ce secret.
    • NAMESPACE : espace de noms cible.

  4. Configurez BackupRepository en appliquant la configuration suivante à votre cluster :

    apiVersion: backup.gdc.goog/v1
kind: BackupRepository
metadata:
  name: REPOSITORY_NAME
spec:
  force: true
  importPolicy: ReadWrite
  localOptions:
    encryptionKey:
      name: SECRET_NAME
      namespace: NAMESPACE
  type: Local

  5. Vérifiez que le cluster peut accéder au dépôt de sauvegarde à l'aide de la commande suivante :

    kubectl get BackupRepository

    Remplacez les éléments suivants :

    • REPOSITORY_NAME : nom descriptif du dépôt.
    • SECRET_NAME : nom du secret Kubernetes que vous avez créé à l'étape précédente.
    • NAMESPACE : espace de noms dans lequel vous avez créé le secret Kubernetes.

Créer un plan de sauvegarde

Un plan de sauvegarde définit la planification automatisée pour l'exécution de la sauvegarde de votre machine virtuelle. Créez une ressource VirtualMachineBackupPlan avec le contenu suivant et appliquez-la à votre cluster :

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupPlan
metadata:
  name: BACKUP_PLAN_NAME
  namespace: NAMESPACE
spec:
  backupConfig:
    backupRepository: REPOSITORY_NAME
    backupScope:
      selectedVirtualMachines:
      - resourceName: VM_NAME
    volumeStrategy: LocalSnapshotOnly
  backupSchedule:
    cronSchedule: "CRON_SCHEDULE"
    paused: PAUSED
  retentionPolicy:
    backupDeleteLockDays: PLAN_LOCK_LENGTH
    backupRetainDays: 4
    locked: RETENTION_POLICY_LOCKED
  numBackupsToRetain: BACKUPS_RETAINED

Remplacez les éléments suivants :

  • BACKUP_PLAN_NAME : nom descriptif du plan de sauvegarde.
  • NAMESPACE : nom de l'espace de noms cible.
  • REPOSITORY_NAME : dépôt de sauvegarde cible.
  • CRON_SCHEDULE : planning standard cron pour l'exécution des sauvegardes. L'intervalle minimal autorisé entre les sauvegardes est de 10 minutes.
  • PAUSED : indique si ce plan de sauvegarde est mis en veille. Les valeurs valides sont true et false.
  • VM_NAME : spécifie une charge de travail de machine virtuelle à sauvegarder avec ce plan de sauvegarde. Vous pouvez spécifier plusieurs ressources de machine virtuelle par plan de sauvegarde.
  • * BACKUP_LOCK_LENGTH : spécifie le nombre de jours après la création de la sauvegarde pendant lesquels elle ne peut pas être supprimée.
  • * BACKUP_RETENTION_LENGTH : spécifie le nombre de jours de conservation de cette sauvegarde. Lorsque la période de conservation expire, la sauvegarde est supprimée. Si aucune valeur n'est spécifiée, la valeur par défaut est 4.
  • * RETENTION_POLICY_LOCKED : indique si la règle de conservation de ce plan de sauvegarde est verrouillée. Les valeurs valides sont true et false.
  • * BACKUPS_RETAINED/var> : spécifie le nombre de sauvegardes à conserver dans ce plan de sauvegarde. Lorsque ce seuil est atteint, les sauvegardes sont supprimées de la plus ancienne à la plus récente.

Lister les plans de sauvegarde existants

Pour lister les plans de sauvegarde existants, utilisez la commande suivante :

kubectl get VirtualMachineBackupPlans -A

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

NAMESPACE      NAME                                LASTBACKUPTIME   LASTBACKUPSTATE   NEXTBACKUPTIME   PAUSED
vm-workloads   bkp-template-vm-windows-vm-local
vm-workloads   sched-snapshotonly-bkp-plan-10min                                                       false

Créer une sauvegarde manuelle d'une machine virtuelle

Suivez les étapes de cette section pour créer une sauvegarde manuelle d'une machine virtuelle.

  1. Créez une ressource VirtualMachineBackupPlanTemplate dans l'espace de noms dans lequel réside la machine virtuelle cible en appliquant la configuration suivante au cluster :

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupPlanTemplate
metadata:
  name: TEMPLATE_NAME
  namespace: NAMESPACE
spec:
  backupRepository: REPOSITORY_NAME

    Remplacez les éléments suivants :

    • TEMPLATE_NAME : nom descriptif de ce modèle de sauvegarde.
    • REPOSITORY_NAME : nom du dépôt de sauvegarde cible.
    • NAMESPACE : espace de noms cible.

  2. Déclenchez la sauvegarde en créant une ressource VirtualMachineBackupRequest avec la configuration suivante et en l'appliquant au cluster :

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupRequest
metadata:
  name: BACKUP_REQUEST_NAME
  namespace: NAMESPACE
spec:
  vmBackupPlanTemplate: TEMPLATE_NAME
  virtualMachine: VM_NAME
  vmBackupName: BACKUP_NAME

    Remplacez les éléments suivants :

    • BACKUP_REQUEST_NAME : nom descriptif de cette demande de sauvegarde.
    • TEMPLATE_NAME : nom du modèle de sauvegarde que vous avez créé à l'étape précédente.
    • NAMESPACE : nom de l'espace de noms cible.
    • VM_NAME : nom de la machine virtuelle cible.
    • BACKUP_NAME : nom descriptif de cette sauvegarde.

  3. Vérifiez l'intégrité de la sauvegarde à l'aide de la commande suivante :

    kubectl get vmbackup BACKUP_NAME -n NAMESPACE

    Remplacez les éléments suivants :

    • BACKUP_NAME : nom de la sauvegarde cible.
    • NAMESPACE : espace de noms cible.

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

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackup
metadata:
  creationTimestamp: "2024-04-09T17:57:44Z"
  finalizers:
  - vm.cluster.gke.io/virtual-machine-backup-finalizer
  generation: 1
  name: vmt13-backup-0409-2
  namespace: default
  ownerReferences:
  - apiVersion: backup.gdc.goog/v1
    kind: Backup
    name: vmt13-backup-0409-2
    uid: 0ee0b92c-1e27-48cc-8f8f-5606ea925e88
  resourceVersion: "36192759"
  uid: e471f8c7-637c-485f-acda-108017a5638f
spec:
  backupConfig:
    backupRepository: default
    backupScope:
      selectedVirtualMachines:
      - resourceName: vm-t13
    volumeStrategy: Portable
  vmBackupPlan: MyVmPlan-vm-vm-t13-portable
status:
  backedUpVirtualMachineDisks:
  - vm-t13-boot-disk
  - vm-t13-data-disk
  backedUpVirtualMachines:
  - vm-t13
  backup: vmt13-backup-0409-2
  backupStatus:
    clusterMetadata:
      k8sVersion: "1.28"
    completeTime: "2024-04-09T18:07:36Z"
    createTime: "2024-04-09T17:57:44Z"
    jobCreated: true
    resourceCount: 849
    sizeBytes: 1948672
    state: Succeeded

Lister les sauvegardes de machines virtuelles

Pour afficher les sauvegardes de machines virtuelles existantes, utilisez la commande suivante :

kubectl get VirtualMachineBackups -A

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

NAMESPACE      NAME        STATE       CREATETIME
vm-workloads   vm-backup   Succeeded   2025-04-08T04:37:32Z

Restaurer une machine virtuelle à partir d'une sauvegarde

Suivez les étapes de cette section pour restaurer une machine virtuelle à partir d'une sauvegarde.

  1. Déclenchez le processus de restauration en créant une ressource VirtualMachineRestoreRequest avec la configuration suivante et en l'appliquant à votre cluster :

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineRestoreRequest
metadata:
  name: restore-req
  namespace: NAMESPACE
spec:
  vmBackup: BACKUP_NAME
  restoreName: RESTORE_NAME
  restoredResourceName: RESTORED_VM_NAME
  restoredResourceDescription: RESTORE_DESCRIPTION

    Remplacez les éléments suivants :

    • BACKUP_NAME : nom de la sauvegarde cible.
    • RESTORE_NAME : nom descriptif de cette opération de restauration.
    • NAMESPACE : espace de noms cible.
    • RESTORED_VM_NAME : nom attribué à la machine virtuelle lors de la restauration. Ce nom ne doit pas entrer en conflit avec les machines virtuelles déjà présentes sur le cluster.
    • RESTORE_DESCRIPTION : description de cette opération de restauration.

  2. Utilisez la commande suivante pour vérifier la progression de l'opération de restauration :

    kubectl get virtualmachinerestores.vm.cluster.gke.io RESTORE_NAME -n NAMESPACE

    Remplacez les éléments suivants :

    • RESTORE_NAME : nom de l'opération de restauration cible.
    • NAMESPACE : espace de noms cible.

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

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineRestore
metadata:
  creationTimestamp: "2024-04-09T18:09:51Z"
  finalizers:
  - vm.cluster.gke.io/virtual-machine-restore-finalizer
  generation: 1
  name: vmt13-restore-0409-2-1
  namespace: default
  ownerReferences:
  - apiVersion: backup.gdc.goog/v1
    kind: Restore
    name: vmt13-restore-0409-2-1
    uid: 4ce1ca83-eba0-4cc3-bad3-af6cf9185d7d
  resourceVersion: "36194596"
  uid: aba50b59-e18d-4687-ad11-47baa45478b4
spec:
  targetVirtualMachineDisks:
  - vm-t13-boot-disk
  - vm-t13-data-disk
  targetVirtualMachines:
  - vm-t13
  vmBackup: vmt13-backup-0409-2
status:
  restore: vmt13-restore-0409-2-1
  restoreStatus:
    completeTime: "2024-04-09T18:10:00Z"
    jobCreated: true
    resourcesRestoredCount: 5
    restoredVolumesCount: 2
    startTime: "2024-04-09T18:09:51Z"
    state: Succeeded
    stateReason: restore is successful

Afficher les opérations de restauration

Pour afficher les opérations de restauration lancées à ce jour, utilisez la commande suivante :

kubectl get VirtualMachineRestore.vm.cluster.gke.io -A

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

NAMESPACE      NAME        STARTTIME              RESTORE     STATE
vm-workloads   restore-1   2025-04-08T04:41:04Z   restore-1   Succeeded

Supprimer une sauvegarde de machine virtuelle

Pour supprimer une sauvegarde de machine virtuelle, créez une ressource VirtualMachineDeleteBackupRequest avec la configuration suivante et appliquez-la à votre cluster :

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachineDeleteBackupRequest
    metadata:
      name: vmdbr
      namespace: BACKUP_NAME
    spec:
      vmBackup: NAMESPACE

Remplacez les éléments suivants :

  • NAMESPACE : nom de l'espace de noms cible.
  • BACKUP_NAME : nom de la sauvegarde cible.

Afficher les journaux d'audit du bac à sable AppArmor

Distributed Cloud connecte automatiquement les charges de travail des machines virtuelles aux bacs à sable avec des règles AppArmor dans audit-mode. Toute infraction aux règles génère une entrée de journal'audit. Exemple :

{
  "jsonPayload": {
    "_SOURCE_REALTIME_TIMESTAMP": "1734596844149104",
    "SYSLOG_TIMESTAMP": "Dec 19 08:27:24 ",
    "MESSAGE": "type=AVC msg=audit(1734596844.148:27742): apparmor=\"ALLOWED\" operation=\"open\" profile=\"virt-launcher-audit\" name=\"/etc/libvirt/virtlogd.conf\" pid=182406 comm=\"virtlogd\" requested_mask=\"r\" denied_mask=\"r\" fsuid=0 ouid=0 FSUID=\"root\" OUID=\"root\"",
    "PRIORITY": "6",
    ...
    "SYSLOG_RAW": "<14>Dec 19 08:27:24 audisp-syslog: type=AVC msg=audit(1734596844.148:27742): apparmor=\"ALLOWED\" operation=\"open\" profile=\"virt-launcher-audit\" name=\"/etc/libvirt/virtlogd.conf\" pid=182406 comm=\"virtlogd\" requested_mask=\"r\" denied_mask=\"r\" fsuid=0 ouid=0 FSUID=\"root\" OUID=\"root\"\n",
    "SYSLOG_IDENTIFIER": "audisp-syslog",
    "_GID": "0",
  },
  "timestamp": "2024-12-19T08:27:24.149109Z",
  "labels": {
    "gke.googleapis.com/log_type": "system"
  },
  "receiveTimestamp": "2024-12-19T08:27:24.721842807Z"
  ...
  ...
}

Étapes suivantes