Créer des nœuds à locataire unique

Les nœuds à locataire unique sont des serveurs physiques dédiés à l'hébergement d'instances de VM propres à votre projet. En hébergeant vos VM sur des nœuds à locataire unique, vous vous assurez que vos instances de VM ne partagent pas de matériel physique avec des instances de VM d'autres projets. Pour en savoir plus sur le fonctionnement des nœuds à locataire unique, consultez la page Présentation des nœuds à locataire unique.

Les nœuds font partie d'un groupe de nœuds, que vous créez. Un groupe de nœuds peut contenir plusieurs instances de tailles différentes, toutes isolées des autres projets. Vous pouvez définir des affinités de nœuds pour vous assurer que les instances de VM s'exécutent dans des groupes de nœuds spécifiques.

Consultez la section Tarifs applicables aux nœuds à locataire unique afin de savoir comment calculer les prix et les remises pour les nœuds à locataire unique.

Avant de commencer

Restrictions

Consultez la section Restrictions de la présentation des nœuds à locataire unique avant de créer et d'utiliser des nœuds de ce type.

Créer et utiliser des nœuds à locataire unique

En général, vous devez procéder comme suit pour créer des instances sur des nœuds à locataire unique :

  1. Créez un modèle de nœud qui spécifie le type de nœud ou le processeur virtuel, ainsi que les exigences en termes de mémoire. Indiquez également une région, et éventuellement des libellés d'affinité de nœuds. Lorsque vous créez vos VM, vous pouvez spécifier qu'elles ne s'exécutent que sur des nœuds correspondant aux étiquettes d'affinité de nœuds.
  2. Servez-vous du modèle pour créer un groupe de nœuds avec un ou plusieurs nœuds à locataire unique. Vous pouvez réduire le nombre de nœuds à zéro lorsqu'ils ne vous sont plus utiles.
  3. Créez des instances sur vos groupes de nœuds :
    • Créez des instances de VM individuelles sur le groupe de nœuds en utilisant un type de machine ou un type de machine personnalisé. Le type de machine doit comporter au moins deux processeurs virtuels.
    • Créez des groupes d'instances gérés sur le groupe de nœuds à l'aide d'un modèle d'instance. Sachez qu'un autoscaler peut contrôler la taille d'un groupe d'instances géré sur vos nœuds, mais pas la taille du groupe de nœuds.

Créer des groupes de nœuds et des instances

Créez un modèle de nœud pour définir les propriétés des nœuds dans un groupe. Une fois le modèle créé, utilisez-le pour créer un ou plusieurs groupes de nœuds. Ensuite, créez des instances sur ces groupes de nœuds.

Console

Créez un nœud et ses instances à l'aide de la console Google Cloud Platform :

  1. Accédez à la page des nœuds à locataire unique.

    Accéder à la page des nœuds à locataire unique

  2. Cliquez sur Créer un modèle de nœud pour commencer la création.
  3. Spécifiez la région dans laquelle vous prévoyez d'exécuter votre groupe de nœuds.
  4. Indiquez le type de nœud que vos groupes de nœuds doivent utiliser. Vous pouvez également préciser le plus petit nœud disponible, ce qui permet l'exécution des groupes de nœuds sur n'importe quel type de nœud disponible.
  5. Si vous le souhaitez, ajoutez des étiquettes d'affinité de nœuds pour déterminer les instances qui se planifient automatiquement sur vos groupes de nœuds. Si les étiquettes d'affinité restent vides, vous pourrez toujours planifier des instances ultérieurement sur vos groupes de nœuds en fonction du nom du groupe de nœuds ou du nom du nœud individuel.
  6. Cliquez sur Créer pour terminer la création du modèle de nœud.

Servez-vous du modèle de nœud pour créer un groupe de nœuds.

  1. Accédez à la page des nœuds à locataire unique.

    Accéder à la page des nœuds à locataire unique

  2. Cliquez sur Créer un groupe de nœuds pour commencer la création.
  3. Spécifiez la zone dans laquelle vous voulez exécuter votre groupe de nœuds. Un modèle de nœud doit exister dans la même région.
  4. Indiquez le modèle de nœud à utiliser.
  5. Précisez le nombre de nœuds à exécuter dans le groupe. Vous pourrez modifier ce nombre par la suite.
  6. Cliquez sur Créer pour terminer la création du groupe de nœuds.

Créez une instance qui s'exécute dans votre groupe de nœuds ou sur des nœuds spécifiques. Si vous avez utilisé des étiquettes d'affinité de nœuds spécifiques, vous pouvez créer une instance en suivant le processus normal et spécifier l'affinité de nœuds dans les paramètres de location unique. Pour cet exemple, créez les instances directement depuis la page d'informations sur le groupe de nœuds.

  1. Accédez à la page des nœuds à locataire unique.

    Accéder à la page des nœuds à locataire unique

  2. Cliquez sur le nom du groupe de nœuds dans lequel créer une instance.
  3. Cliquez sur Créer une instance pour créer une instance n'importe où dans ce groupe de nœuds. Si vous souhaitez que l'instance s'exécute sur un nœud spécifique du groupe, cliquez sur le nom du nœud dans le groupe pour afficher les détails correspondants. Ensuite, cliquez sur Créer une instance pour créer l'instance sur ce nœud.
  4. Configurez les paramètres de l'instance. La région, la zone et les étiquettes d'affinité de nœuds par défaut sont déjà indiquées étant donné que vous avez déjà sélectionné le groupe de nœuds ou un nœud spécifique.
  5. Cliquez sur Créer pour terminer la création de l'instance.

gcloud

Créez un nœud et ses instances à l'aide de l'outil de ligne de commande gcloud :

  1. Exécutez la commande compute sole-tenancy node-types list pour identifier les types de nœuds disponibles :

    gcloud compute sole-tenancy node-types list
    

    Compute Engine remplace régulièrement les anciens types de nœuds par des types plus récents. Lorsqu'un type de nœud est remplacé, vous ne pouvez pas créer de groupes de nœuds à l'aide de l'ancien type, et vous devez mettre à jour vos modèles de nœuds pour utiliser les nouveaux types.

  2. Exécutez la commande compute sole-tenancy node-templates create pour créer un modèle de nœud. Étant donné que la liste des types de nœuds disponibles change au fil du temps, configurez vos modèles de nœuds avec des exigences de type de nœud flexibles. Par exemple, spécifiez --node-requirements vCPU=any,memory=any,localSSD=0, ce qui permet au nœud de s'exécuter sur n'importe quel type de nœud disponible sans disque dur SSD local.

    gcloud compute sole-tenancy node-templates create [TEMPLATE_NAME] \
        --region [REGION] --node-requirements vCPU=any,memory=any,localSSD=0
    

    où :

    • [TEMPLATE_NAME] est le nom du nouveau modèle de nœud.
    • [REGION] est la région dans laquelle vous utiliserez ce modèle.

    Vous pouvez également sélectionner un type de nœud spécifique à utiliser dans votre modèle. Ce modèle est moins flexible, mais vous permet de créer des nœuds uniquement s'ils répondent à vos exigences exactes en processeur virtuel et en mémoire système.

     gcloud compute sole-tenancy node-templates create [TEMPLATE_NAME] \
         --node-type [NODE_TYPE] --region [REGION]
    

    où :

    • [TEMPLATE_NAME] est le nom du nouveau modèle de nœud.
    • [NODE_TYPE] est le type de nœud à utiliser pour ce modèle. Par exemple, vous pouvez spécifier le type de nœud n1-node-96-624 pour créer un nœud avec 96 processeurs virtuels et 624 Go de mémoire système.
    • [REGION] est la région dans laquelle vous utiliserez ce modèle.
  3. Après avoir créé le modèle de nœud, créez un groupe de nœuds. Exécutez la commande compute sole-tenancy node-groups create :

    gcloud compute sole-tenancy node-groups create [GROUP_NAME] --zone [ZONE] \
        --node-template [TEMPLATE_NAME] --target-size [TARGET_SIZE]
    

    où :

    • [GROUP_NAME] est le nom du nouveau groupe de nœuds.
    • [ZONE] est la zone où se trouve le groupe de nœuds. Cette zone doit appartenir à la même région que le modèle de nœud que vous utilisez.
    • [TEMPLATE_NAME] est le nom du modèle de nœud permettant de créer le groupe.
    • [TARGET_SIZE] est le nombre de nœuds à créer dans le groupe.
  4. Après avoir créé votre groupe de nœuds, vous pouvez créer des instances dans ce groupe à l'aide de la commande compute instances create. Spécifiez un indicateur --node-group qui pointe vers le nom de votre groupe de nœuds. Par exemple, vous pouvez créer une instance avec un type de machine personnalisé :

    gcloud compute instances create [INSTANCE_NAME] --zone [ZONE] \
        --image-family [IMAGE_FAMILY] --image-project [IMAGE_PROJECT] \
        --node-group [GROUP_NAME] --custom-cpu [VCPUS] --custom-memory [MEMORY]
    

    où :

    • [INSTANCE_NAME] est le nom de la nouvelle instance.
    • [ZONE] est la zone où se trouve le groupe de nœuds.
    • [IMAGE_FAMILY] est l'une des familles d'images disponibles.
    • [IMAGE_PROJECT] est le projet d'image auquel appartient la famille d'images.
    • [GROUP_NAME] est le nom du groupe de nœuds dans lequel placer l'instance.
    • [VCPUS] est le nombre de processeurs virtuels à utiliser avec cette instance.
    • [MEMORY] est la quantité de mémoire système pour l'instance, par tranches de 256 Mo. Par exemple, vous pouvez indiquer 5.25GB ou 5376MB.

    Vous pouvez également créer des groupes d'instances gérés au sein de votre groupe de nœuds. Créez un modèle d'instance à l'aide de la commande instance-templates create, puis incluez un indicateur --node-group qui pointe vers le nom de votre groupe de nœuds :

    gcloud compute instance-templates create [INSTANCE_TEMPLATE] \
        --image-family [IMAGE_FAMILY] --image-project [IMAGE_PROJECT] \
        --node-group [GROUP_NAME] \
        --custom-cpu [VCPUS] --custom-memory [MEMORY]
    

    où :

    • [INSTANCE_TEMPLATE] est le nom du nouveau modèle d'instance.
    • [IMAGE_FAMILY] est l'une des familles d'images disponibles.
    • [IMAGE_PROJECT] est le projet d'image auquel appartient la famille d'images.
    • [GROUP_NAME] est le nom du groupe de nœuds dans lequel placer l'instance.
    • [VCPUS] est le nombre de processeurs virtuels à utiliser avec cette instance.
    • [MEMORY] est la quantité de mémoire système pour l'instance, par tranches de 256 Mo. Par exemple, vous pouvez indiquer 5.25GB ou 5376MB.

    Créez un groupe d'instances à l'aide de la commande compute instance-groups managed create :

    gcloud compute instance-groups managed create [INSTANCE_GROUP_NAME] \
        --zone [ZONE] --size [SIZE] --template [INSTANCE_TEMPLATE]
    

    où vous remplacez les valeurs suivantes :

    • [INSTANCE_GROUP_NAME] est le nom du groupe d'instances.
    • [SIZE] est le nombre d'instances de VM à inclure dans le groupe d'instances. Votre groupe de nœuds doit disposer de suffisamment de ressources pour prendre en charge les instances de ce groupe d'instances géré.
    • [INSTANCE_TEMPLATE] est le nom du modèle d'instance permettant de créer le groupe. Le modèle doit disposer d'une affinité de nœuds pointant vers le groupe de nœuds souhaité.
    • [ZONE] est la zone où se trouve le groupe de nœuds.

API

Créez un nœud et ses instances à l'aide des méthodes de l'API Compute Engine :

  1. Dans l'API, créez une requête GET pour récupérer la liste des types de nœuds disponibles à l'aide de la méthode compute.nodetypes.list :

    GET https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/nodeTypes
    

    où :

    • [PROJECT_ID] est l'ID de votre projet.
    • [ZONE] est la zone à partir de laquelle récupérer les types de nœuds disponibles.
  2. Envoyez une requête POST à la méthode compute.nodetemplates.insert pour créer un modèle de nœud. Pour plus de flexibilité, spécifiez une propriété nodeTypeFlexibility avec les valeurs cpus et memory définies sur any, ce qui permet au nœud de s'exécuter sur n'importe quel type disponible sans disque dur SSD local.

    POST https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/[REGION]/nodeTemplates
    
    {
     "name": "[TEMPLATE_NAME]",
     "nodeTypeFlexibility": {
      "cpus": "any",
      "memory": "any"
     }
    }
    

    où :

    • [PROJECT_ID] est l'ID de votre projet.
    • [REGION] est la zone à partir de laquelle récupérer les types de nœuds disponibles.
    • [TEMPLATE_NAME] est le nom du nouveau modèle de nœud.

    Vous pouvez également sélectionner un type de nœud spécifique à utiliser dans votre modèle. Ce modèle est moins flexible, mais vous permet de créer des nœuds uniquement s'ils répondent à vos exigences exactes en processeur virtuel et en mémoire système.

    POST https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/[REGION]/nodeTemplates
    
    {
     "name": "[TEMPLATE_NAME]",
     "nodeType": "[NODE_TYPE]"
    }
    

    où :

    • [PROJECT_ID] est l'ID de votre projet.
    • [TEMPLATE_NAME] est le nom du nouveau modèle de nœud.
    • [NODE_TYPE] est le type de nœud à utiliser pour ce modèle. Par exemple, vous pouvez spécifier le type de nœud n1-node-96-624 pour créer un nœud avec 96 processeurs virtuels et 624 Go de mémoire système.
    • [REGION] est la région dans laquelle vous utiliserez ce modèle.
  3. Après avoir créé le modèle de nœud, créez un groupe de nœuds. Utilisez la méthode compute.nodeGroups.insert :

    POST https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/nodeGroups?initialNodeCount=[TARGET_SIZE]
    
    {
     "nodeTemplate": "regions/[REGION]/nodeTemplates/[TEMPLATE_NAME]",
     "name": "[GROUP_NAME]"
    }
    

    où :

    • [PROJECT_ID] est l'ID de votre projet.
    • [ZONE] est la zone où se trouve le groupe de nœuds. Cette zone doit appartenir à la même région que le modèle de nœud que vous utilisez.
    • [TARGET_SIZE] est le nombre de nœuds à créer dans le groupe.
    • [REGION] est la région où se trouve le modèle de nœud.
    • [TEMPLATE_NAME] est le nom du nouveau modèle de nœud.
    • [GROUP_NAME] est le nom du nouveau groupe de nœuds.
    • [TEMPLATE_NAME] est le nom du modèle de nœud permettant de créer le groupe.
  4. Après avoir créé le groupe de nœuds, vous pouvez créer des instances dans ce groupe à l'aide de la méthode compute.instances.insert. Spécifiez une entrée nodeAffinities qui pointe vers le nom de votre groupe de nœuds. Par exemple, vous pouvez créer une instance avec un type de machine personnalisé :

    POST https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instances
    
    {
     "machineType": "zones/[ZONE]/machineTypes/custom-[VCPUS]-[MEMORY]",
     "name": "[INSTANCE_NAME]",
     "scheduling": {
      "nodeAffinities": [
       {
        "key": "compute.googleapis.com/node-group-name",
        "operator": "IN",
        "values": [
         "[GROUP_NAME]"
        ]
       }
      ]
     },
     "networkInterfaces": [
      {
       "network": "global/networks/[NETWORK]",
       "subnetwork": "regions/[REGION]/subnetworks/[SUBNETWORK]"
      }
     ],
     "disks": [
      {
       "boot": true,
       "initializeParams": {
        "sourceImage": "projects/[IMAGE_PROJECT]/global/images/family/[IMAGE_FAMILY]"
       }
      }
     ]
    }
    

    où :

    • [PROJECT_ID] est l'ID de votre projet.
    • [INSTANCE_NAME] est le nom de la nouvelle instance.
    • [ZONE] est la zone où se trouve le groupe de nœuds.
    • [REGION] est la région où se trouvent le modèle de nœud et le sous-réseau.
    • [IMAGE_FAMILY] est l'une des familles d'images disponibles.
    • [IMAGE_PROJECT] est le projet d'image auquel appartient la famille d'images.
    • [GROUP_NAME] est le nom du groupe de nœuds dans lequel placer l'instance.
    • [VCPUS] est le nombre de processeurs virtuels à utiliser avec cette instance.
    • [MEMORY] est la quantité en Mo de mémoire système pour l'instance. Par exemple, vous pouvez indiquer 5376MB.
    • [NETWORK] est le nom du réseau auquel connecter votre instance.
    • [SUBNETWORK] est le nom du sous-réseau auquel connecter votre instance.

    Vous pouvez également créer des groupes d'instances gérés au sein de votre groupe de nœuds. Créez un modèle d'instance à l'aide de la méthode compute.instanceTemplates.insert, puis spécifiez une entrée nodeAffinities qui pointe vers le nom de votre groupe de nœuds :

    POST https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instance-templates
    
    {
    "name": "[TEMPLATE_NAME]",
    "properties": {
       "machineType": "custom-[VCPUS]-[MEMORY]",
       "name": "[INSTANCE_NAME]",
       "scheduling": {
        "nodeAffinities": [
         {
          "key": "compute.googleapis.com/node-group-name",
          "operator": "IN",
          "values": [
           "[GROUP_NAME]"
          ]
         }
        ]
       },
       "networkInterfaces": [
        {
         "network": "global/networks/[NETWORK]",
         "subnetwork": "regions/[REGION]/subnetworks/[SUBNETWORK]"
        }
       ],
       "disks": [
        {
         "boot": true,
         "initializeParams": {
          "sourceImage": "projects/[IMAGE_PROJECT]/global/images/family/[IMAGE_FAMILY]"
         }
        }
       ]
      }
    }
    

    où :

    • [PROJECT_ID] est l'ID de votre projet.
    • [INSTANCE_NAME] est le nom de la nouvelle instance.
    • [ZONE] est la zone où se trouve le groupe de nœuds.
    • [REGION] est la région où se trouvent le modèle de nœud et le sous-réseau.
    • [TEMPLATE_NAME] est le nom du nouveau modèle d'instance.
    • [IMAGE_FAMILY] est l'une des familles d'images disponibles.
    • [IMAGE_PROJECT] est le projet d'image auquel appartient la famille d'images.
    • [GROUP_NAME] est le nom du groupe de nœuds dans lequel placer l'instance.
    • [VCPUS] est le nombre de processeurs virtuels à utiliser avec cette instance.
    • [MEMORY] est la quantité en Mo de mémoire système pour l'instance. Par exemple, vous pouvez indiquer 5376MB.
    • [NETWORK] est le nom du réseau auquel connecter votre instance.
    • [SUBNETWORK] est le nom du sous-réseau auquel connecter votre instance.

    Créez un groupe d'instances à l'aide de la méthode compute.instanceGroupManagers.insert :

    POST https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instanceGroupManagers
    
    {
     "baseInstanceName": "default",
     "name": "[INSTANCE_GROUP_NAME]",
     "targetSize": [SIZE],
     "instanceTemplate": "global/instanceTemplates/[INSTANCE_TEMPLATE]"
    }
    

    où :

    • [PROJECT_ID] est l'ID de votre projet.
    • [ZONE] est la zone où se trouve le groupe de nœuds.
    • [INSTANCE_GROUP_NAME] est le nom du groupe d'instances.
    • [BASE_INSTANCE_NAME] est le nom de préfixe de chacune des instances de votre groupe d'instances géré.
    • [SIZE] est le nombre d'instances de VM à inclure dans le groupe d'instances. Votre groupe de nœuds doit disposer de suffisamment de ressources pour prendre en charge les instances de ce groupe d'instances géré.
    • [INSTANCE_TEMPLATE] est le nom du modèle d'instance permettant de créer le groupe. Le modèle doit disposer d'une affinité de nœuds pointant vers le groupe de nœuds souhaité.

Options de nœud à locataire unique

Vous trouverez ci-dessous des options supplémentaires que vous pouvez spécifier pour vos modèles de nœuds.

Option de redémarrage minimal du serveur

Lorsque cette option est définie, si un événement de maintenance se produit, les VM de ce groupe de nœuds seront redémarrées sur le même serveur physique, si possible. Si celui-ci n'est pas disponible, un serveur physique est créé et ajouté au groupe de nœuds.

Cette option diffère des étiquettes d'affinité de nœuds, qui garantissent simplement que certaines VM sont créées sur des nœuds dotés d'étiquettes spécifiques et n'ont aucune incidence sur le fait que le serveur physique sous-jacent reste le même pendant toute la durée de vie du groupe de nœuds.

Pour spécifier cette option :

Console

Sur la page Créer un modèle de nœud, développez Configuration avancée de redémarrage du nœud et sélectionnez Nombre de serveurs minimal.

gcloud

Avec l'outil gcloud, spécifiez l'indicateur --server-binding restart-node-on-minimal-servers lorsque vous créez un modèle de nœud.

API

Lorsque vous effectuez une requête HTTP directe, fournissez l'objet serverBinding, en intégrant la chaîne type: restart-node-on-minimal-servers dans la requête lors de la création d'un modèle de nœud.

{
  "serverBinding":
    {
      "type": "RESTART_NODE_ON_MINIMAL_SERVERS"
    }
}

Configurer l'affinité de nœuds

Vous pouvez définir des affinités ou des anti-affinités de nœuds pour déterminer les nœuds que vos instances et groupes d'instances gérés utilisent en tant que systèmes hôtes. Lorsque vous définissez des affinités de nœuds, vous choisissez explicitement quels nœuds à locataire unique hébergent quelles VM.

Par défaut, chaque nœud se voit attribuer les étiquettes d'affinité suivantes :

  • Chaque nœud d'un groupe possède une étiquette d'affinité correspondant au nom du groupe de nœuds :
    • Clé : compute.googleapis.com/node-group-name
    • Valeur : nom du groupe de nœuds
  • Chaque nœud possède une étiquette d'affinité correspondant au nom du nœud. Les noms de nœuds sont générés automatiquement :
    • Clé : compute.googleapis.com/node-name
    • Valeur : nom du nœud concerné

Vous pouvez configurer des étiquettes d'affinité ou d'anti-affinité supplémentaires afin que vos instances ne s'exécutent que sur les groupes de nœuds souhaités ou ne partagent des nœuds qu'avec des instances ayant la même affinité. Vous rassemblez ainsi les données sensibles sur des groupes de nœuds spécifiques, séparés de vos autres groupes de nœuds et des autres instances de VM exécutées sur Compute Engine.

Par exemple, vous pouvez créer un groupe de nœuds pour le développement et un groupe de nœuds distinct pour les charges de travail de production. Vous pouvez utiliser le processus suivant :

  1. Créez deux modèles de nœuds avec deux étiquettes différentes, workload=frontend,environment=prod et workload=frontend,environment=dev. L'étiquette workload indique que les groupes de nœuds sont destinés aux charges de travail frontend, tandis que l'étiquette environment fait la distinction entre les environnements prod et dev :

    gcloud compute sole-tenancy node-templates create production-template \
       --node-requirements vCPU=any,memory=any,localSSD=0 --node-affinity-labels workload=frontend,environment=prod
    
    gcloud compute sole-tenancy node-templates create development-template \
       --node-requirements vCPU=any,memory=any,localSSD=0 --node-affinity-labels workload=frontend,environment=dev
    
  2. Créez plusieurs groupes de nœuds à l'aide des modèles de production et de développement. Par exemple, vous pouvez utiliser un vaste groupe de nœuds de production et plusieurs groupes de nœuds de développement plus petits. Si vous le souhaitez, vous pouvez créer ces groupes dans différentes zones et avec différentes tailles de cibles afin de gérer l'étendue des charges de travail :

    gcloud compute sole-tenancy node-groups create production-group \
        --node-template production-template --target-size 5 --zones us-west1-b
    
    gcloud compute sole-tenancy node-groups create development-group-east1 \
        --node-template development-template --target-size 1 --zones us-east1-d
    
    gcloud compute sole-tenancy node-groups create development-group-east2 \
        --node-template development-template --target-size 1 --zones us-east1-d
    
  3. Pour les instances de production, créez un fichier node-affinity-prod.json afin de définir plus clairement l'exécution de l'affinité sur ces instances. Par exemple, vous pouvez créer un fichier qui demande aux instances de ne s'exécuter que sur les nœuds avec les affinités workload=frontend et environment=prod :

    [{
    "key" : "workload",
    "operator" : "IN",
    "values" : ["frontend"]
    },
    {
    "key" : "environment",
    "operator" : "IN",
    "values" : ["prod"]
    }
    ]
    
  4. Servez-vous du fichier node-affinity-prod.json pour créer un modèle d'instance avec les propriétés souhaitées pour vos instances de VM de production :

    gcloud compute instance-templates create production-template \
        --image-family production-images --image-project my-project \
        --node-affinity-file node-affinity-prod.json \
        --custom-cpu 3 --custom-memory 4096
    
  5. Démarrez un groupe d'instances à l'aide du modèle de production qui s'exécute sur votre nœud de production :

    gcloud compute instance-groups managed create production-group \
        --zone us-west1-b --size 4 --template production-template
    

    Les instances du groupe démarrent. Elles ne s'exécutent que sur les groupes de nœuds avec les affinités workload=frontend et environment=prod.

Configurer des étiquettes d'anti-affinité

L'exemple ci-dessus explique comment utiliser les étiquettes d'affinité. Vous pouvez également vous servir d'étiquettes d'anti-affinité pour vous assurer que vos VM évitent les nœuds portant certaines étiquettes. Supposons qu'en plus des instances de VM de production que vous avez créées ci-dessus, vous souhaitez également créer des instances de VM à des fins de développement, mais sans avoir à les héberger sur les mêmes nœuds que ceux hébergeant vos instances de production.

  1. Pour les instances de développement, créez un fichier node-affinity-dev.json afin de définir plus clairement le fonctionnement de l'affinité sur ces instances. Par exemple, vous pouvez créer un fichier qui configure l'exécution des instances sur n'importe quel groupe de nœuds ayant l'affinité workload=frontend, tant que la valeur n'est pas environment=prod :

    [{
    "key" : "workload",
    "operator" : "IN",
    "values" : ["frontend"]
    },
    {
    "key" : "environment",
    "operator" : "NOT",
    "values" : ["prod"]
    }
    ]
    
  2. Pour le développement, vous pouvez créer une instance individuelle afin d'effectuer des tests plutôt que tout un groupe d'instances. Servez-vous du fichier node-affinity-dev.json pour créer cette instance. Par exemple, si vous souhaitez tester une image de développement spécifique nommée development-image-1, vous devez créer l'instance et configurer ses affinités à l'aide de la commande suivante :

    gcloud compute instances create dev-1 \
        --image development-image-1 --image-project my-project \
        --node-affinity-file node-affinity-dev.json \
        --custom-cpu 3 --custom-memory 4096 --zone us-east1-d
    

    Cette instance démarre. Elle ne s'exécute que sur les groupes de nœuds présentant workload=frontend. Cependant, elle ne fonctionnera sur aucun groupe de nœuds configuré avec l'affinité environment=prod.

Pour créer vos propres configurations d'affinité, créez un modèle de nœud et exécutez des nœuds avec vos clés et valeurs d'affinité. Configurez ensuite les instances avec vos fichiers affinity.json, qui déterminent les nœuds sur lesquels vos instances peuvent s'exécuter.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation Compute Engine