Consommer des ressources zonales réservées

Autopilot Standard

---

Vous pouvez réserver des instances Compute Engine dans une zone spécifique pour vous assurer que des ressources sont disponibles en temps voulu pour vos charges de travail. Pour en savoir plus sur la gestion des réservations, consultez la page Réserver des ressources zonales Compute Engine.

Après avoir créé des réservations, vous pouvez consommer les ressources réservées dans GKE. GKE est compatible avec les mêmes modes de consommation que Compute Engine :

• Consommer des ressources de n'importe quelle réservation : Standard uniquement
• Consommer des ressources d'une réservation spécifique : Standard et Autopilot
• Créer des nœuds sans consommer de réservation : Standard et Autopilot

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.
  Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

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 de Compute. Vous devez utiliser la classe de calcul Accelerator ou la classe de calcul 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 à l'aide de la classe de calcul d'accélérateur : 1.28.6-gke.1095000 ou ultérieure
  • Pour utiliser la classe de calcul des performances : 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-h100-80gb : NVIDIA H100 (80 Go) (disponible uniquement avec la classe de calcul Accelerator)
  • nvidia-a100-80gb : NVIDIA A100 (80 Go)
  • nvidia-tesla-a100 : NVIDIA A100 (40 Go)
  • nvidia-l4 : NVIDIA L4
  • nvidia-tesla-t4 : NVIDIA T4

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

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.

kubectl

1. Enregistrez le fichier manifeste suivant sous le nom specific-autopilot.yaml. Ce fichier manifeste contient des sélecteurs de nœuds qui consomment une réservation spécifique. Vous pouvez utiliser des instances de VM ou des accélérateurs.

   Instances de VM

     apiVersion: v1
     kind: Pod
     metadata:
       name: specific-same-project-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-affinity: "specific"
       containers:
       - name: my-container
         image: "k8s.gcr.io/pause"
         resources:
           requests:
             cpu: 12
             memory: "50Gi"
             ephemeral-storage: "200Gi"
   

   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.

   Accélérateurs

     apiVersion: v1
     kind: Pod
     metadata:
       name: specific-same-project-pod
     spec:
       nodeSelector:
         cloud.google.com/compute-class: "Accelerator"
         cloud.google.com/gke-accelerator: ACCELERATOR
         cloud.google.com/reservation-name: RESERVATION_NAME
         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-h100-80gb : NVIDIA H100 (80 Go) (disponible uniquement avec la classe de calcul Accelerator)
     • 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.
   • 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.

2. Déployez le pod :

   kubectl apply -f specific-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.

Terraform

Pour utiliser une réservation spécifique dans le même projet avec des instances de VM à l'aide de Terraform, reportez-vous à l'exemple suivant :

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

Pour utiliser une réservation spécifique dans le même projet avec la classe de calcul de l'accélérateur à l'aide de Terraform, reportez-vous à l'exemple suivant :

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

Pour en savoir plus sur l'utilisation de Terraform, consultez la page Compatibilité de Terraform avec GKE.

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:[e-mail] \
       --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: 12
           memory: "50Gi"
           ephemeral-storage: "200Gi"
   

   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

   apiVersion: v1
   kind: Pod
   metadata:
     name: specific-same-project-pod
   spec:
     nodeSelector:
       cloud.google.com/compute-class: "Accelerator"
       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-h100-80gb : NVIDIA H100 (80 Go) (disponible uniquement avec la classe de calcul Accelerator)
     • 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.

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.

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 qui consomment n'importe quelle réservation à l'aide de gcloud CLI ou de Terraform.

gcloud

Pour consommer automatiquement toutes les réservations correspondantes, définissez l'option d'affinité de réservation sur --reservation-affinity=any. Étant donné que any est la valeur définie par défaut dans Compute Engine, vous pouvez complètement omettre l'option d'affinité de réservation.

Lorsque vous utilisez le mode de consommation des réservations any, les nœuds exploitent d'abord les réservations dans un seul projet avant les réservation partagées, car celles-ci sont davantage disponibles pour les autres projets. Pour en savoir plus sur la consommation automatique des instances, consultez la page Ordre de consommation.

1. Créez une réservation pour trois instances de VM :

   gcloud compute reservations create RESERVATION_NAME \
       --machine-type=MACHINE_TYPE --vm-count=3
   

   Remplacez les éléments suivants :

   • RESERVATION_NAME : le nom de la réservation à créer.
   • MACHINE_TYPE : type de machine (nom uniquement) à utiliser pour la réservation. Exemple :n1-standard-2

2. Vérifiez que la réservation a bien été créée :

   gcloud compute reservations describe RESERVATION_NAME
   

3. Créez un cluster comportant un nœud pour consommer n'importe quelle réservation correspondante :

   gcloud container clusters create CLUSTER_NAME \
       --machine-type=MACHINE_TYPE --num-nodes=1 \
       --reservation-affinity=any
   

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

4. Créez un pool de nœuds doté de trois nœuds pour consommer toute réservation correspondante :

   gcloud container node-pools create NODEPOOL_NAME \
       --cluster CLUSTER_NAME --num-nodes=3 \
       --machine-type=MACHINE_TYPE --reservation-affinity=any
   

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

Le nombre total de nœuds est de quatre, ce qui dépasse la capacité de la réservation. Trois nœuds consomment donc la réservation, tandis que le dernier nœud exploite le pool général de ressources Compute Engine.

Terraform

Pour créer une réservation de trois instances de VM à l'aide de Terraform, reportez-vous à l'exemple suivant :

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

  specific_reservation {
    count = 3

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

Pour créer un cluster comportant un nœud pour consommer n'importe quelle réservation correspondante à l'aide de Terraform, reportez-vous à l'exemple suivant :

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
  ]

  # Set `deletion_protection` to `true` will ensure that one cannot
  # accidentally delete this instance by use of Terraform.
  deletion_protection = false
}

Pour créer un pool de nœuds doté de trois nœuds afin de consommer toute réservation correspondante à l'aide de Terraform, reportez-vous à l'exemple suivant :

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

Pour en savoir plus sur l'utilisation de Terraform, consultez la page Compatibilité de Terraform avec GKE.

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.

gcloud

1. Créez une réservation spécifique pour trois instances de VM :

   gcloud compute reservations create RESERVATION_NAME \
       --machine-type=MACHINE_TYPE --vm-count=3 \
       --require-specific-reservation
   

   Remplacez les éléments suivants :

   • RESERVATION_NAME : le nom de la réservation à créer.
   • MACHINE_TYPE : type de machine (nom uniquement) à utiliser pour la réservation. Exemple :n1-standard-2

2. Créez un pool de nœuds avec un seul nœud pour consommer une réservation spécifique à un seul projet :

   gcloud container node-pools create NODEPOOL_NAME \
       --cluster CLUSTER_NAME \
       --machine-type=MACHINE_TYPE --num-nodes=1 \
       --reservation-affinity=specific --reservation=RESERVATION_NAME
   

   Remplacez les éléments suivants :

   • NODEPOOL_NAME : nom du pool de nœuds à créer.
   • CLUSTER_NAME : nom du cluster que vous avez créé.

Terraform

Pour créer une réservation spécifique à l'aide de Terraform, reportez-vous à l'exemple suivant :

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
}

Pour créer un pool de nœuds avec un seul nœud afin de consommer une réservation spécifique pour un projet unique à l'aide de Terraform, reportez-vous à l'exemple suivant :

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

Pour en savoir plus sur l'utilisation de Terraform, consultez la page Compatibilité de Terraform avec GKE.

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.

gcloud

1. Créez une réservation partagée spécifique :

   gcloud compute reservations create RESERVATION_NAME \
       --machine-type=MACHINE_TYPE --vm-count=3 \
       --zone=ZONE \
       --require-specific-reservation \
       --project=OWNER_PROJECT_ID \
       --share-setting=projects \
       --share-with=CONSUMER_PROJECT_IDS
   

   Remplacez les éléments suivants :

   • RESERVATION_NAME : nom de la réservation à créer.
   • MACHINE_TYPE : nom du type de machine à utiliser pour la réservation. Exemple :n1-standard-2
   • OWNER_PROJECT_ID (facultatif) : ID du projet pour lequel vous souhaitez créer cette réservation partagée. Si vous omettez l'option --project, GKE utilise par défaut le projet actuel en tant que projet propriétaire.
   • CONSUMER_PROJECT_IDS : liste des identifiants de projets avec lesquels vous souhaitez partager cette réservation, séparés par une virgule. Exemple : project-1,project-2. Vous pouvez inclure entre 1 et 100 projets clients. Ces projets doivent appartenir à la même organisation que le projet propriétaire. N'incluez pas l'OWNER_PROJECT_ID, car il peut utiliser cette réservation par défaut.

2. Consommez la réservation partagée :

     gcloud container node-pools create NODEPOOL_NAME \
         --cluster CLUSTER_NAME \
         --machine-type=MACHINE_TYPE --num-nodes=1 \
         --reservation-affinity=specific \
         --reservation=projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME
   

   Remplacez les éléments suivants :

   • NODEPOOL_NAME : nom du pool de nœuds à créer.
   • CLUSTER_NAME : nom du cluster que vous avez créé.

Terraform

Pour créer une réservation partagée spécifique à l'aide de Terraform, reportez-vous à l'exemple suivant :

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
}

Pour utiliser la réservation partagée spécifique à l'aide de Terraform, reportez-vous à l'exemple suivant :

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

Pour en savoir plus sur l'utilisation de Terraform, consultez la page Compatibilité de Terraform avec GKE.

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.

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.

Réservation 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 de gcloud container node-pools create.
• Les réservations TPU ne peuvent pas être partagées entre plusieurs projets.

Pour en savoir plus, consultez la page Réservations TPU.

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
• En savoir 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.