Définir un emplacement compact pour les nœuds GKE

Vous pouvez contrôler si vos nœuds Google Kubernetes Engine (GKE) sont physiquement situés les uns par rapport aux autres dans une zone à l'aide d'une stratégie d'emplacement compact.

Présentation

Lorsque vous créez des pools de nœuds et des charges de travail dans un cluster GKE, vous pouvez définir une stratégie d'emplacement compact, qui spécifie que ces nœuds ou charges de travail doivent être proches les uns des autres dans une zone. Le fait de disposer de nœuds plus proches les uns des autres permet de réduire la latence du réseau entre les nœuds, ce qui peut être particulièrement utile pour les charges de travail par lot à couplage fort.

Utiliser un emplacement compact avec GKE Autopilot

Limites

  • GKE provisionne des charges de travail dans un emplacement compact de la même zone.
  • L'emplacement compact est disponible sur le GPU Balanced et A100. Pour en savoir plus, consultez la page présentant les types de machines.
  • L'emplacement compact est disponible pour les pods regroupés sur un maximum de 150 nœuds.
  • La migration à chaud des nœuds n'est pas disponible.

Activer une stratégie d'emplacement compact

Pour activer l'emplacement compact pour GKE Autopilot, ajoutez un élément nodeSelector à la spécification de pod avec les clés suivantes:

  • cloud.google.com/gke-placement-group est l'identifiant que vous attribuez au groupe de pods devant s'exécuter ensemble dans le même groupe d'emplacements compacts.

  • L'une des clés suivantes pour définir le type de ressource:

    • cloud.google.com/compute-class: "Balanced"
    • cloud.google.com/gke-accelerator: "nvidia-tesla-a100"

L'exemple suivant est un extrait d'une spécification de pod qui active l'emplacement compact. L'identifiant du groupe d'emplacements est placement-group-1 et la classe de calcul est Balanced:

  nodeSelector:
    cloud.google.com/gke-placement-group: "placement-group-1"
    cloud.google.com/compute-class: "Balanced"

Chaque groupe d'emplacements est limité à 150 nœuds. Nous vous recommandons de limiter un groupe d'emplacements uniquement aux charges de travail qui bénéficient du regroupement, et de répartir vos charges de travail dans des groupes d'emplacements distincts si possible.

Utiliser un emplacement compact avec GKE Standard

Limites

L'emplacement compact dans les pools de nœuds GKE Standard présente les limites suivantes :

Créer une règle d'emplacement compact

Pour créer des règles de concentration dans Google Cloud CLI, spécifiez l'option placement-type=COMPACT lors de la création du pool de nœuds ou du cluster. Avec ce paramètre, GKE tente de placer les nœuds dans un pool de nœuds plus près les uns des autres.

Pour utiliser une stratégie de ressource existante dans votre cluster, spécifiez l'emplacement de votre stratégie personnalisée pour l'option placement-policy lors de la création du pool de nœuds ou du cluster. Vous bénéficiez ainsi de la flexibilité nécessaire pour utiliser des emplacements réservés, plusieurs pools de nœuds avec la même stratégie d'emplacement, ainsi que d'autres options d'emplacement avancées. Cependant, cela nécessite également plus d'opérations manuelles que de spécifier l'option -placement-type=COMPACT. Par exemple, vous devez créer, supprimer et gérer vos stratégies de ressources personnalisées. Assurez-vous que le nombre maximal d'instances de VM est respecté sur tous les pools de nœuds à l'aide de la stratégie de ressource. Si cette limite est atteinte alors que certains de vos pools de nœuds n'ont pas atteint leur taille maximale, l'ajout d'autres nœuds va échouer.

Si vous ne spécifiez pas les options placement-type et placement-policy, alors par défaut aucune condition n'est imposée pour l'emplacement des nœuds.

Créer une règle de concentration dans un nouveau cluster

Lorsque vous créez un cluster, vous pouvez spécifier une règle de concentration qui sera appliquée au pool de nœuds par défaut. Pour tout pool de nœuds que vous créez par la suite, vous devrez spécifier si vous souhaitez appliquer un emplacement compact.

Pour créer un cluster dans lequel une règle de concentration est appliquée au pool de nœuds par défaut, utilisez la commande suivante :

gcloud container clusters create CLUSTER_NAME \
    --machine-type MACHINE_TYPE \
    --placement-type COMPACT \
    --max-surge-upgrade 0 \
    --max-unavailable-upgrade MAX_UNAVAILABLE

Remplacez les éléments suivants :

  • CLUSTER_NAME : nom de votre nouveau cluster.
  • MACHINE_TYPE : type de machine à utiliser pour les nœuds, qui doit être un type de machine C2 (par exemple, c2-standard-4)
  • --placement-type COMPACT : applique un emplacement compact pour les nœuds du pool par défaut.
  • MAX_UNAVAILABLE : nombre maximal de nœuds pouvant être indisponibles simultanément lors d'une mise à niveau du pool de nœuds. Pour les emplacements compacts, nous vous recommandons d'effectuer des mises à niveau rapides, sans mise à niveau de la surutilisation, afin d'optimiser la probabilité de trouver des nœuds colocalisés lors des mises à niveau.

Créer une règle de concentration sur un cluster existant

Sur un cluster existant, vous pouvez créer un pool de nœuds auquel une règle de concentration est appliquée.

Pour créer un pool de nœuds auquel une règle de concentration est appliquée, utilisez la commande suivante :

gcloud container node-pools create NODEPOOL_NAME \
    --machine-type MACHINE_TYPE \
    --cluster CLUSTER_NAME \
    --placement-type COMPACT \
    --max-surge-upgrade 0 \
    --max-unavailable-upgrade MAX_UNAVAILABLE

Remplacez les éléments suivants :

  • NODEPOOL_NAME : nom de votre nouveau pool de nœuds.
  • MACHINE_TYPE : type de machine à utiliser pour les nœuds, qui doit être un type de machine C2 (par exemple, c2-standard-4)
  • CLUSTER_NAME : nom de votre cluster existant.
  • --placement-type COMPACT : indique d'appliquer un emplacement compact pour les nœuds du nouveau pool de nœuds.
  • MAX_UNAVAILABLE : nombre maximal de nœuds pouvant être indisponibles simultanément lors d'une mise à niveau du pool de nœuds. Pour les emplacements compacts, nous vous recommandons d'effectuer des mises à niveau rapides, sans mise à niveau de la surutilisation, afin d'optimiser la probabilité de trouver des nœuds colocalisés lors des mises à niveau.

Créer des pools de nœuds à l'aide d'une stratégie d'emplacement personnalisée partagée

Vous pouvez créer manuellement une stratégie de ressource et l'utiliser dans plusieurs pools de nœuds.

  1. Créez la stratégie de ressource dans la région Google Cloud du cluster :

    gcloud compute resource-policies create group-placement POLICY_NAME \
    --region REGION \
    --collocation collocated

    Remplacez les éléments suivants :

    • POLICY_NAME : nom de votre stratégie de ressource.
    • REGION : région de votre cluster.

  2. Créez un pool de nœuds à l'aide de la stratégie de ressource personnalisée :

    gcloud container node-pools create NODEPOOL_NAME \
    --machine-type MACHINE_TYPE \
    --cluster CLUSTER_NAME \
    --placement-policy POLICY_NAME \
    --max-surge-upgrade 0 \
    --max-unavailable-upgrade MAX_UNAVAILABLE

    Remplacez les éléments suivants :

    • NODEPOOL_NAME : nom de votre nouveau pool de nœuds.
    • MACHINE_TYPE : type de machine à utiliser pour les nœuds, qui doit être un type de machine C2 (par exemple, c2-standard-4)
    • CLUSTER_NAME : nom de votre cluster existant.
    • MAX_UNAVAILABLE : nombre maximal de nœuds pouvant être indisponibles simultanément lors d'une mise à niveau du pool de nœuds. Pour les emplacements compacts, nous vous recommandons d'effectuer des mises à niveau rapides, sans mise à niveau de la surutilisation, afin d'optimiser la probabilité de trouver des nœuds colocalisés lors des mises à niveau.

Utiliser une réservation Compute Engine avec une stratégie d'emplacement compact

Les réservations vous aident à garantir la disponibilité du matériel dans la zone spécifiée, ce qui réduit le risque d'échec de création du pool de nœuds pour cause de matériel insuffisant.

  1. Créez une réservation qui spécifie une stratégie d'emplacement compact :

    gcloud compute reservations create RESERVATION_NAME \
    --vm-count MACHINE_COUNT \
    --machine-type MACHINE_TYPE \
    --resource-policies policy=POLICY_NAME \
    --zone ZONE \
    --require-specific-reservation

    Remplacez les éléments suivants :

    • RESERVATION_NAME : nom de votre réservation.
    • MACHINE_COUNT : nombre de nœuds réservés.
    • MACHINE_TYPE : type de machine à utiliser pour les nœuds, qui doit être un type de machine C2 Par exemple, pour utiliser un type de machine C2 prédéfini avec 4 processeurs virtuels, spécifiez c2-standard-4.
    • POLICY_NAME : nom de votre stratégie de ressource.
    • ZONE : zone dans laquelle créer votre réservation.

  2. Créez un pool de nœuds en spécifiant à la fois la stratégie d'emplacement compact et la réservation que vous avez créée à l'étape précédente :

    gcloud container node-pools create NODEPOOL_NAME \
    --machine-type MACHINE_TYPE \
    --cluster CLUSTER_NAME \
    --placement-policy POLICY_NAME \
    --reservation-affinity specific \
    --reservation RESERVATION_NAME \
    --max-surge-upgrade 0 \
    --max-unavailable-upgrade MAX_UNAVAILABLE

Remplacez les éléments suivants :

  • NODEPOOL_NAME : nom de votre nouveau pool de nœuds.
  • MACHINE_TYPE : type de machine à utiliser pour les nœuds, qui doit être un type de machine C2 (par exemple, c2-standard-4)
  • CLUSTER_NAME : nom de votre cluster existant.

Créer une charge de travail sur des nœuds utilisant un emplacement compact

Pour exécuter des charges de travail sur des nœuds dédiés utilisant un emplacement compact, vous pouvez utiliser plusieurs mécanismes Kubernetes, tels que l'attribution de pods aux nœuds et l'arrêt de la planification des pods indésirables sur un groupe de nœuds pour y parvenir.

Dans l'exemple suivant, nous ajoutons un rejet aux nœuds dédiés, ainsi qu'une tolérance et une affinité correspondantes aux pods.

  1. Ajoutez un rejet aux nœuds du pool de nœuds associés à une règle de concentration :

    kubectl taint nodes -l cloud.google.com/gke-nodepool=NODEPOOL_NAME dedicated-pool=NODEPOOL_NAME:NoSchedule

  2. Dans la définition de la charge de travail, spécifiez la tolérance et l'affinité de nœud nécessaires. Voici un exemple avec un seul pod :

    apiVersion: v1
kind: Pod
metadata:
  ...
spec:
  ...
  tolerations:
  - key: dedicated-pool
    operator: "Equal"
    value: "NODEPOOL_NAME"
    effect: "NoSchedule"
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: dedicated-pool
            operator: In
            values:
            - NODEPOOL_NAME

Dans certains emplacements, il peut être impossible de créer un pool de nœuds volumineux à l'aide d'une règle de concentration. Pour limiter la taille de ces pools de nœuds aux besoins nécessaires, vous pouvez envisager de créer un pool de nœuds par charge de travail nécessitant un emplacement compact.

Utiliser l'emplacement compact pour le provisionnement automatique des nœuds

À partir de la version 1.25 de GKE, le provisionnement automatique des nœuds est compatible avec la stratégie d'emplacement compact. Le provisionnement automatique de nœuds permet à GKE de provisionner automatiquement des pools de nœuds en fonction des besoins en ressources des clusters. Pour en savoir plus, consultez la page Utiliser le provisionnement automatique des nœuds.

Pour activer l'emplacement compact pour le provisionnement automatique des nœuds, ajoutez un nodeSelector à la spécification de pod avec les clés suivantes :

  • cloud.google.com/gke-placement-group est l'identifiant que vous attribuez au groupe de pods devant s'exécuter ensemble dans le même groupe d'emplacements compacts.

  • cloud.google.com/machine-family est le nom de la famille de machines. Utilisez l'une des familles de machines compatibles avec l'emplacement compact. Nous vous recommandons d'utiliser des familles de machines C2 ou C2D pour les charges de travail présentant des exigences de performances en matière de calcul et de mise en réseau.

L'exemple suivant est une spécification de pod qui active l'emplacement compact :

apiVersion: v1
kind: Pod
metadata:
  ...
spec:
  ...
  nodeSelector:
    cloud.google.com/gke-placement-group: PLACEMENT_GROUP_IDENTIFIER
    cloud.google.com/machine-family: MACHINE_FAMILY

Vous pouvez omettre la clé cloud.google.com/machine-family si la configuration du pod définit déjà un type de machine compatible avec l'emplacement compact. Par exemple, si la spécification de pod inclut nvidia.com/gpu et que le cluster est configuré pour utiliser des GPU A100, vous n'avez pas besoin d'inclure la clé cloud.google.com/machine-family.

L'exemple suivant est une spécification de pod qui définit la requête nvidia.com/gpu. Le cluster est configuré pour utiliser des GPU A100. Ce pod spec n'inclut pas la clé cloud.google.com/machine-family :

  apiVersion: v1
  kind: Pod
  metadata:
    ...
  spec:
    ...
    nodeSelector:
      cloud.google.com/gke-placement-group: PLACEMENT_GROUP_IDENTIFIER
      cloud.google.com/gke-accelerator: "nvidia-tesla-a100"
    resources:
      limits:
        nvidia.com/gpu: 2

Pour en savoir plus, consultez la page Configurer des pods pour qu'ils utilisent des GPU.

Optimiser la taille du groupe d'emplacements

Étant donné que GKE trouve le meilleur emplacement pour des déploiements plus petits, nous vous recommandons d'indiquer à GKE d'éviter d'exécuter différents types de pods dans le même groupe d'emplacements. Ajoutez une clé de tolérance avec la clé cloud.google.com/gke-placement-group et l'identifiant d'emplacement compact que vous avez défini.

L'exemple suivant est une spécification de pod qui définit une tolérance de pod avec un emplacement compact :

apiVersion: v1
kind: Pod
metadata:
  ...
spec:
  ...
  tolerations:
  - key: cloud.google.com/gke-placement-group
    operator: "Equal"
    value: PLACEMENT_GROUP_IDENTIFIER
    effect: "NoSchedule"

Pour en savoir plus sur le provisionnement automatique des nœuds avec la tolérance aux pods, consultez la section Séparation des charges de travail.

Étapes suivantes