Consommer des ressources zonales réservées

Cette page explique comment utiliser les ressources zonales Compute Engine réservées dans des charges de travail GKE spécifiques. Ces réservations de capacité vous offrent un niveau élevé d'assurance quant à la disponibilité de matériel spécifique pour vos charges de travail.

Assurez-vous de bien maîtriser les concepts des réservations Compute Engine, comme les types de consommation, les types de partage et les types de provisionnement. Pour en savoir plus, consultez Réservations de ressources zonales Compute Engine.

Cette page est destinée aux personnes suivantes :

• Les opérateurs d'applications qui déploient des charges de travail devant s'exécuter le plus rapidement possible, généralement avec du matériel spécialisé comme des GPU.
• Les administrateurs de plate-forme qui souhaitent obtenir un niveau d'assurance élevé que les charges de travail s'exécutent sur du matériel optimisé répondant aux exigences de l'application et de l'organisation.

À propos de la consommation de réservations dans GKE

Les réservations de capacité Compute Engine vous permettent de provisionner des configurations matérielles spécifiques dans des zones Google Cloud , immédiatement ou à une date ultérieure spécifique. Vous pouvez ensuite consommer cette capacité réservée dans GKE.

En fonction de votre mode de fonctionnement GKE, vous pouvez utiliser les types de réservations suivants :

• Mode Autopilot : réservations spécifiques uniquement.
• Mode standard : réservations spécifiques ou toute réservation correspondante.

Pour activer la consommation de réservations afin de créer vos ressources, vous devez spécifier une affinité de réservation, comme any ou specific.

Options de consommation des réservations dans GKE

GKE vous permet de consommer des réservations directement dans des charges de travail individuelles en utilisant des nodeSelectors Kubernetes dans le fichier manifeste de votre charge de travail ou en créant des pools de nœuds en mode Standard qui consomment la réservation. Cette page décrit l'approche consistant à sélectionner directement les réservations dans des ressources individuelles.

Vous pouvez également configurer GKE pour qu'il utilise des réservations lors des opérations de scaling qui créent des nœuds à l'aide de classes de calcul personnalisées. Les classes de calcul personnalisées permettent aux administrateurs de plate-forme de définir une hiérarchie de configurations de nœuds que GKE doit hiérarchiser lors du scaling des nœuds. Les charges de travail s'exécutent ainsi sur le matériel de votre choix.

Vous pouvez spécifier des réservations dans la configuration de votre classe de calcul personnalisée afin que toute charge de travail GKE qui utilise cette classe de calcul personnalisée indique à GKE de consommer les réservations spécifiées pour cette classe de calcul.

Pour en savoir plus, consultez la section Utiliser les réservations Compute Engine sur la page "À propos des classes de calcul personnalisées".

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

• Activez l'API Google Kubernetes Engine.
Activer l'API Google Kubernetes Engine
• Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.

Consommer des réservations de capacité dans des clusters Autopilot

Les clusters Autopilot sont compatibles avec la consommation de ressources de réservations de capacité Compute Engine dans le même projet ou dans un projet partagé. Vous devez définir la propriété de type de consommation de la réservation cible sur specific et sélectionner explicitement cette réservation dans votre fichier manifeste. Si vous ne spécifiez pas explicitement une réservation, les clusters Autopilot ne consommeront pas de réservations. Pour en savoir plus sur les types de consommation de réservations, consultez la section Fonctionnement des réservations.

Ces réservations sont éligibles aux remises sur engagement d'utilisation flexibles Compute. Vous devez utiliser la classe de calcul Accelerator ou Performance pour consommer des réservations de capacité.

• Avant de commencer, créez un cluster Autopilot exécutant les versions suivantes :

  • Pour utiliser des accélérateurs réservés, tels que des GPU : 1.28.6-gke.1095000 ou version ultérieure
  • Pour exécuter des pods sur une série de machines spécifique et avec chaque pod sur son propre nœud : 1.28.6-gke.1369000 et versions ultérieures, ou version 1.29.1-gke.1575000 et ultérieure.

Créer des réservations de capacité pour Autopilot

Les pods Autopilot peuvent consommer des réservations ayant la propriété de type de consommation specific dans le même projet que le cluster ou dans une réservation partagée d'un autre projet. Vous pouvez utiliser le matériel réservé en référençant explicitement cette réservation dans votre fichier manifeste. Vous pouvez utiliser les réservations dans Autopilot pour les types de matériel suivants :

• L'un des types de GPU suivants :

  • nvidia-b200 : NVIDIA B200 (180 Go)
  • nvidia-h200-141gb : NVIDIA H200 (141 Go)
  • nvidia-h100-mega-80gb : NVIDIA H100 Mega (80 Go)
  • nvidia-h100-80gb : NVIDIA H100 (80 Go)
  • nvidia-a100-80gb : NVIDIA A100 (80 Go)
  • nvidia-tesla-a100 : NVIDIA A100 (40 Go)
  • nvidia-l4 : NVIDIA L4
  • nvidia-tesla-t4 : NVIDIA T4

• L'un des types de TPU suivants :

  • tpu-v6e-slice : tranche TPU v6e
  • tpu-v5p-slice : tranche de TPU v5p
  • tpu-v5-lite-podslice : tranche de pod TPU v5 Lite
  • tpu-v5-lite-device : appareil TPU v5 Lite
  • tpu-v4-lite-device : appareil TPU v4 Lite
  • tpu-v4-podslice : tranche de pod TPU v4
  • tpu-v3-device : appareil TPU v3
  • tpu-v3-slice : tranche de pod TPU v3

Pour créer une réservation de capacité, consultez les ressources suivantes. La réservation doit répondre aux exigences suivantes :

• Les types de machines, les types et les quantités d'accélérateurs correspondent à la consommation de vos charges de travail.

• La réservation utilise le type de consommation specific. Par exemple, dans gcloud CLI, vous devez spécifier l'option --require-specific-reservation lorsque vous créez la réservation.

• Créer une réservation pour un seul projet

• Créer une réservation partagée

GKE associe automatiquement les SSD locaux de la réservation spécifique sélectionnée à votre nœud. Vous n'avez pas besoin de sélectionner des disques SSD locaux individuels dans le fichier manifeste de votre charge de travail. Par exemple, si la réservation que vous sélectionnez inclut deux disques SSD locaux, les nœuds que GKE crée à partir de cette réservation sont associés à deux disques SSD locaux.

Consommer une réservation spécifique dans le même projet dans Autopilot

Cette section vous explique comment utiliser une réservation de capacité spécifique située dans le même projet que votre cluster. Vous pouvez utiliser kubectl ou Terraform.

resource "kubernetes_pod_v1" "default_pod" {
  metadata {
    name = "specific-same-project-pod"
  }

  spec {
    node_selector = {
      "cloud.google.com/compute-class"        = "Performance"
      "cloud.google.com/machine-family"       = "c3"
      "cloud.google.com/reservation-name"     = google_compute_reservation.specific_pod.name
      "cloud.google.com/reservation-affinity" = "specific"
    }

    container {
      name  = "my-container"
      image = "registry.k8s.io/pause"

      resources {
        requests = {
          cpu               = 2
          memory            = "8Gi"
          ephemeral-storage = "1Gi"
        }
      }

      security_context {
        allow_privilege_escalation = false
        run_as_non_root            = false

        capabilities {
          add  = []
          drop = ["NET_RAW"]
        }
      }
    }

    security_context {
      run_as_non_root     = false
      supplemental_groups = []

      seccomp_profile {
        type = "RuntimeDefault"
      }
    }
  }

  depends_on = [
    google_compute_reservation.specific_pod
  ]
}

resource "kubernetes_pod_v1" "default_accelerator" {
  metadata {
    name = "specific-same-project-accelerator"
  }

  spec {
    node_selector = {
      "cloud.google.com/compute-class"        = "Accelerator"
      "cloud.google.com/gke-accelerator"      = "nvidia-l4"
      "cloud.google.com/reservation-name"     = google_compute_reservation.specific_accelerator.name
      "cloud.google.com/reservation-affinity" = "specific"
    }

    container {
      name  = "my-container"
      image = "registry.k8s.io/pause"

      resources {
        requests = {
          cpu               = 2
          memory            = "7Gi"
          ephemeral-storage = "1Gi"
          "nvidia.com/gpu"  = 1

        }
        limits = {
          "nvidia.com/gpu" = 1
        }
      }

      security_context {
        allow_privilege_escalation = false
        run_as_non_root            = false

        capabilities {
          add  = []
          drop = ["NET_RAW"]
        }
      }
    }

    security_context {
      run_as_non_root     = false
      supplemental_groups = []

      seccomp_profile {
        type = "RuntimeDefault"
      }
    }
  }

  depends_on = [
    google_compute_reservation.specific_accelerator
  ]
}

Consommer une réservation partagée spécifique dans Autopilot

Cette section utilise les termes suivants :

• Projet propriétaire : projet propriétaire de la réservation qui la partage avec d'autres projets.
• Projet client : le projet qui exécute les charges de travail qui consomment la réservation partagée.

Pour utiliser une réservation partagée, vous devez autoriser l'agent de service GKE à accéder à la réservation du projet propriétaire de la réservation. Procédez comme suit :

1. Créez un rôle IAM personnalisé contenant l'autorisation compute.reservations.list dans le projet propriétaire :

   gcloud iam roles create ROLE_NAME \
       --project=OWNER_PROJECT_ID \
       --permissions='compute.reservations.list'
   

   Remplacez les éléments suivants :

   • ROLE_NAME : nom de votre nouveau rôle.
   • OWNER_PROJECT_ID : ID du projet propriétaire de la réservation de capacité.

2. Accordez à l'agent de service GKE du projet client l'accès pour répertorier les réservations partagées dans le projet propriétaire :

   gcloud projects add-iam-policy-binding OWNER_PROJECT_ID \
       --project=OWNER_PROJECT_ID \
       --member=serviceAccount:service-CONSUMER_PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com \
       --role='projects/OWNER_PROJECT_ID/roles/ROLE_NAME'
   

   Remplacez CONSUMER_PROJECT_NUMBER par le numéro de projet de votre projet client. Pour trouver ce numéro, consultez la section Identifier des projets dans la documentation Resource Manager.

3. Enregistrez le fichier manifeste suivant sous le nom shared-autopilot.yaml. Ce fichier manifeste contient des sélecteurs de nœuds qui indiquent à GKE de consommer une réservation partagée spécifique.

   Instances de VM

   apiVersion: v1
   kind: Pod
   metadata:
     name: performance-pod
   spec:
     nodeSelector:
       cloud.google.com/compute-class: Performance
       cloud.google.com/machine-family: MACHINE_SERIES
       cloud.google.com/reservation-name: RESERVATION_NAME
       cloud.google.com/reservation-project: OWNER_PROJECT_ID
       cloud.google.com/reservation-affinity: "specific"
     containers:
     - name: my-container
       image: "k8s.gcr.io/pause"
       resources:
         requests:
           cpu: 2
           memory: "4Gi"
   

   Remplacez les éléments suivants :

   • MACHINE_SERIES : série de machines contenant le type de machine des VM dans votre réservation de capacité spécifique. Par exemple, si votre réservation concerne les types de machines c3-standard-4, spécifiez c3 dans le champ MACHINE_SERIES.
   • RESERVATION_NAME : nom de la réservation de capacité Compute Engine.
   • OWNER_PROJECT_ID : ID du projet propriétaire de la réservation de capacité.

   Accélérateurs de GPU

   apiVersion: v1
   kind: Pod
   metadata:
     name: specific-same-project-pod
   spec:
     nodeSelector:
       cloud.google.com/gke-accelerator: ACCELERATOR
       cloud.google.com/reservation-name: RESERVATION_NAME
       cloud.google.com/reservation-project: OWNER_PROJECT_ID
       cloud.google.com/reservation-affinity: "specific"
     containers:
     - name: my-container
       image: "k8s.gcr.io/pause"
       resources:
         requests:
           cpu: 12
           memory: "50Gi"
           ephemeral-storage: "200Gi"
         limits:
           nvidia.com/gpu: QUANTITY
   

   Remplacez les éléments suivants :

   • ACCELERATOR : accélérateur que vous avez réservé dans la réservation de capacité Compute Engine. Il doit s'agir de l'une des options suivantes :
     • nvidia-b200 : NVIDIA B200 (180 Go)
     • nvidia-h200-141gb : NVIDIA H200 (141 Go)
     • nvidia-h100-mega-80gb : NVIDIA H100 Mega (80 Go)
     • nvidia-h100-80gb : NVIDIA H100 (80 Go)
     • nvidia-a100-80gb : NVIDIA A100 (80 Go)
     • nvidia-tesla-a100 : NVIDIA A100 (40 Go)
     • nvidia-l4 : NVIDIA L4
     • nvidia-tesla-t4 : NVIDIA T4
   • RESERVATION_NAME : nom de la réservation de capacité Compute Engine.
   • OWNER_PROJECT_ID : ID du projet propriétaire de la réservation de capacité.
   • QUANTITY : nombre de GPU à associer au conteneur. Il doit s'agir d'une quantité compatible avec le GPU spécifié, comme décrit dans la section Quantités de GPU compatibles.

   Accélérateurs TPU

   apiVersion: v1
   kind: Pod
   metadata:
     name: specific-shared-project-pod
   spec:
     nodeSelector:
       cloud.google.com/gke-tpu-accelerator: ACCELERATOR
       cloud.google.com/gke-tpu-topology: TOPOLOGY
       cloud.google.com/reservation-name: RESERVATION_NAME
       cloud.google.com/reservation-project: OWNER_PROJECT_ID
       cloud.google.com/reservation-affinity: "specific"
     containers:
     - name: my-container
       image: "k8s.gcr.io/pause"
       resources:
         requests:
           cpu: 12
           memory: "50Gi"
           ephemeral-storage: "200Gi"
         limits:
           google.com/tpu: QUANTITY
   

   Remplacez les éléments suivants :

   • ACCELERATOR : accélérateur que vous avez réservé dans la réservation de capacité Compute Engine. Il doit s'agir de l'une des options suivantes :
     • tpu-v6e-slice : tranche TPU v6e
     • tpu-v5p-slice : tranche de TPU v5p
     • tpu-v5-lite-podslice : tranche de pod TPU v5 Lite
     • tpu-v5-lite-device : appareil TPU v5 Lite
     • tpu-v4-lite-device : appareil TPU v4 Lite
     • tpu-v4-podslice : tranche de pod TPU v4
     • tpu-v3-device : appareil TPU v3
     • tpu-v3-slice : tranche de pod TPU v3
   • TOPOLOGY : topologie du TPU.
   • RESERVATION_NAME : nom de la réservation de capacité Compute Engine.
   • OWNER_PROJECT_ID : ID du projet propriétaire de la réservation de capacité.
   • QUANTITY : nombre de TPU à associer au conteneur. Doit être aligné sur la topologie de TPU.

4. Déployez le pod :

   kubectl apply -f shared-autopilot.yaml
   

Autopilot utilise la capacité réservée dans la réservation spécifiée pour provisionner un nouveau nœud où placer le pod.

Consommer un bloc de réservation spécifique dans Autopilot

Cette section vous explique comment utiliser un bloc de réservation de capacité spécifique situé dans le même projet que votre cluster ou dans un projet partagé. Cette fonctionnalité n'est disponible que pour certains accélérateurs. Vous pouvez utiliser kubectl pour configurer votre pod afin qu'il consomme le bloc de réservation.

1. Enregistrez le fichier manifeste suivant sous le nom reservation-block-autopilot.yaml. Ce fichier manifeste contient des sélecteurs de nœuds qui consomment une réservation spécifique.

   Projet local

   apiVersion: v1
   kind: Pod
   metadata:
     name: specific-same-project-pod
   spec:
     nodeSelector:
       cloud.google.com/gke-accelerator: ACCELERATOR
       cloud.google.com/reservation-name: RESERVATION_NAME
       cloud.google.com/reservation-affinity: "specific"
       cloud.google.com/reservation-blocks: RESERVATION_BLOCKS_NAME
     
     containers:
     - name: my-container
       image: "k8s.gcr.io/pause"
       resources:
         requests:
           cpu: 12
           memory: "50Gi"
           ephemeral-storage: "200Gi"
         limits:
           nvidia.com/gpu: QUANTITY
   

   Remplacez les éléments suivants :

   • ACCELERATOR : accélérateur que vous avez réservé dans la réservation de capacité Compute Engine. Il doit s'agir de l'une des options suivantes :
     • nvidia-b200 : NVIDIA B200 (180 Go)
     • nvidia-h200-141gb : NVIDIA H200 (141 Go)
   • RESERVATION_NAME : nom de la réservation de capacité Compute Engine.
   • RESERVATION_BLOCKS_NAME : nom du bloc de réservation de capacité Compute Engine.
   • QUANTITY : nombre de GPU à associer au conteneur. Il doit s'agir d'une quantité compatible avec le GPU spécifié, comme décrit dans la section Quantités de GPU compatibles.

   Pour les réservations appartenant à un autre projet, ajoutez cloud.google.com/reservation-project: OWNER_PROJECT_ID au champ spec.nodeSelector. Remplacez OWNER_PROJECT_ID par l'ID du projet propriétaire de la réservation de capacité.

2. Déployez le pod :

   kubectl apply -f reservation-block-autopilot.yaml
   

   Autopilot utilise la capacité réservée dans le bloc de réservation spécifié pour provisionner un nouveau nœud où placer le pod.

Résoudre les problèmes de consommation de réservations dans Autopilot

• Assurez-vous que les types de machines, les types d'accélérateurs, les configurations de SSD locaux et les quantités d'accélérateurs correspondent à ce que vos charges de travail consommeront. Pour obtenir la liste complète des propriétés qui doivent correspondre, consultez la section Propriétés de réservation de capacité Compute Engine.
• Assurez-vous que la réservation est créée avec une affinité spécifique.
• Lorsque vous utilisez des réservations partagées, assurez-vous que l'agent de service GKE du projet client est autorisé à répertorier les réservations partagées dans le projet propriétaire.

Utiliser des instances réservées dans GKE Standard

Lorsque vous créez un cluster ou un pool de nœuds, vous pouvez indiquer le mode de consommation de la réservation en spécifiant l'option --reservation-affinity.

Consommer toute réservation correspondante

Vous pouvez créer une réservation et des instances pour utiliser une réservation à l'aide de gcloud CLI ou de Terraform.

resource "google_compute_reservation" "any_reservation" {
  name = "any-reservation"
  zone = "us-central1-a"

  specific_reservation {
    count = 3

    instance_properties {
      machine_type = "e2-medium"
    }
  }
}

resource "google_container_cluster" "default" {
  name     = "gke-standard-zonal-cluster"
  location = "us-central1-a"

  initial_node_count = 1

  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "ANY_RESERVATION"
    }
  }

  depends_on = [
    google_compute_reservation.any_reservation
  ]
}

resource "google_container_node_pool" "any_node_pool" {
  name     = "gke-standard-zonal-any-node-pool"
  cluster  = google_container_cluster.default.name
  location = google_container_cluster.default.location

  initial_node_count = 3
  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "ANY_RESERVATION"
    }
  }
}

Consommer une réservation spécifique à un seul projet

Pour consommer une réservation spécifique, définissez l'option d'affinité de réservation sur --reservation-affinity=specific et indiquez le nom de la réservation spécifique. Dans ce mode, les instances doivent exploiter la réservation spécifiée dans la zone. La requête échoue si la réservation a une capacité insuffisante.

Pour créer une réservation et des instances permettant de consommer une réservation spécifique, procédez comme suit. Vous pouvez utiliser gcloud CLI ou Terraform.

resource "google_compute_reservation" "specific_reservation" {
  name = "specific-reservation"
  zone = "us-central1-a"

  specific_reservation {
    count = 1

    instance_properties {
      machine_type = "e2-medium"
    }
  }

  specific_reservation_required = true
}

resource "google_container_node_pool" "specific_node_pool" {
  name     = "gke-standard-zonal-specific-node-pool"
  cluster  = google_container_cluster.default.name
  location = google_container_cluster.default.location

  initial_node_count = 1
  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key                      = "compute.googleapis.com/reservation-name"
      values                   = [google_compute_reservation.specific_reservation.name]
    }
  }

  depends_on = [
    google_compute_reservation.specific_reservation
  ]
}

Consommer une réservation partagée spécifique

Pour créer une réservation partagée spécifique et consommer la réservation partagée, procédez comme suit. Vous pouvez utiliser gcloud CLI ou Terraform.

1. Suivez les étapes décrites dans la section Autoriser et empêcher les projets de créer et de modifier des réservations partagées.

resource "google_compute_reservation" "specific_reservation" {
  name = "specific-reservation"
  zone = "us-central1-a"

  specific_reservation {
    count = 1

    instance_properties {
      machine_type = "e2-medium"
    }
  }

  specific_reservation_required = true
}

resource "google_container_node_pool" "specific_node_pool" {
  name     = "gke-standard-zonal-specific-node-pool"
  cluster  = google_container_cluster.default.name
  location = google_container_cluster.default.location

  initial_node_count = 1
  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key                      = "compute.googleapis.com/reservation-name"
      values                   = [google_compute_reservation.specific_reservation.name]
    }
  }

  depends_on = [
    google_compute_reservation.specific_reservation
  ]
}

Informations complémentaires à prendre en considération pour une réservation spécifique

Lorsqu'un pool de nœuds est créé avec une affinité de réservation spécifique, y compris ceux définis par défaut lors de la création d'un cluster, sa taille est limitée à la capacité de la réservation spécifique pendant toute la durée de vie du pool de nœuds. Cela affecte les fonctionnalités GKE suivantes :

• Cluster avec plusieurs zones : dans les clusters régionaux ou multizones, les nœuds d'un pool peuvent s'étendre sur plusieurs zones. Comme les réservations ne s'appliquent qu'à une seule zone, vous devez en créer plusieurs. Pour créer un pool de nœuds qui consomme une réservation spécifique dans ces clusters, vous devez créer une réservation spécifique disposant du même nom et des mêmes propriétés machine dans chaque zone du pool de nœuds.
• Autoscaling des clusters et mises à niveau du pool de nœuds : si vous ne disposez pas de capacité supplémentaire dans la réservation spécifique, les mises à niveau du pool de nœuds ou l'autoscaling du pool de nœuds peuvent échouer, car ces deux opérations nécessitent de créer des instances supplémentaires. Pour résoudre ce problème, vous pouvez redimensionner la réservation ou libérer certaines de ses ressources limitées.

Utiliser des réservations de GPU

Pour créer un pool de nœuds Standard qui consomme une réservation de GPU ou toute réservation dont la capacité se trouve dans une seule zone, vous devez spécifier l'indicateur --node-locations lorsque vous ajoutez un pool de nœuds. Lorsque vous créez un cluster Standard régional ou un cluster Standard multizones, la spécification des emplacements des nœuds garantit que GKE ne crée des nœuds que dans une zone où vous avez réservé une capacité de GPU.

Pour obtenir des instructions détaillées sur la création d'un pool de nœuds utilisant des GPU, consultez Créer un pool de nœuds GPU.

Utiliser des réservations TPU

Pour créer un pool de nœuds Standard qui consomme une réservation TPU, vous devez spécifier l'indicateur --node-locations lorsque vous ajoutez un pool de nœuds. Lorsque vous créez un cluster Standard régional ou un cluster Standard multizones, la spécification des emplacements des nœuds permet de s'assurer que GKE ne crée des nœuds que dans une zone où vous avez réservé une capacité de TPU.

Les réservations TPU diffèrent des autres types de machines. Voici les aspects spécifiques au TPU à prendre en compte lors de la création de réservations TPU :

• Lorsque vous utilisez des TPU dans GKE, SPECIFIC est la seule valeur acceptée pour l'option --reservation-affinity.

Pour obtenir des instructions détaillées sur la création d'un pool de nœuds utilisant des TPU, consultez Créer un pool de nœuds TPU.

Créer des nœuds sans consommer de réservation

Pour éviter explicitement de consommer des ressources issues de n'importe quelle réservation, définissez l'option d'affinité sur --reservation-affinity=none.

1. Créez un cluster qui ne consommera aucune réservation :

   gcloud container clusters create CLUSTER_NAME --reservation-affinity=none
   

   Remplacez CLUSTER_NAME par le nom du cluster à créer.

2. Créez un pool de nœuds qui ne consommera aucune réservation :

   gcloud container node-pools create NODEPOOL_NAME \
       --cluster CLUSTER_NAME \
       --reservation-affinity=none
   

   Remplacez NODEPOOL_NAME par le nom du pool de nœuds à créer.

Suivre les réservations disponibles entre les zones

Lorsque vous utilisez des pools de nœuds s'exécutant dans plusieurs zones avec des réservations différentes, vous pouvez utiliser l'option --location_policy=ANY. Cela garantit que lorsque des nœuds sont ajoutés au cluster, ils sont créés dans la zone qui comporte toujours des réservations inutilisées.

Nettoyer

Pour éviter que les ressources utilisées sur cette page soient facturées sur votre compte de facturation Cloud, procédez comme suit :

1. Supprimez les clusters que vous avez créés en exécutant la commande suivante pour chacun d'entre eux :

   gcloud container clusters delete CLUSTER_NAME
   

2. Supprimez les réservations que vous avez créées en exécutant la commande suivante pour chacune d'entre elles :

   gcloud compute reservations delete RESERVATION_NAME
   

Étape suivante

• En savoir plus sur la réservation de ressources zonales Compute Engine
• Apprenez-en plus sur les pools de nœuds.
• En savoir plus sur l'autoscaler de cluster
• Apprenez-en plus sur les stratégies de mise à niveau des nœuds.