Consume recursos zonales reservados

Puedes reservar instancias de Compute Engine de una zona específica a fin de garantizar que estén disponibles los recursos para sus cargas de trabajo cuando sea necesario. Para obtener más información sobre cómo administrar las reservas, consulta Reserva recursos zonales de Compute Engine.

Después de crear reservas, puedes consumir los recursos reservados en GKE. GKE admite los mismos modos de consumo que Compute Engine, que se cubren en las siguientes secciones:

  • Consumo de recursos de cualquier reserva: Solo estándar
  • Consumo de recursos de una reserva específica: Estándar y Autopilot
  • Crea nodos sin consumir ninguna reserva: Standard y Autopilot

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
    • Habilitar la API de Google Kubernetes Engine
  • Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.

Consume reservas de capacidad en clústeres de Autopilot

Los clústeres de Autopilot admiten el consumo de recursos de reservas de capacidad de Compute Engine en el mismo proyecto o en un proyecto compartido. Debes establecer la propiedad de tipo de consumo de la reserva objetivo en específico y debes seleccionar esa reserva de forma explícita en tu manifiesto. Si no especificas una reserva de forma explícita, los clústeres de Autopilot no consumirán reservas. Para obtener más información sobre los tipos de consumo de reservas, consulta Cómo funcionan las reservas.

Estas reservas califican para los descuentos por compromiso de uso de Compute Flexible. Debes usar la clase de procesamiento Accelerator o la clase de procesamiento Performance para consumir las reservas de capacidad.

  • Antes de comenzar, crea un clúster de Autopilot que ejecute las siguientes versiones:

    • Para consumir aceleradores reservados con la clase de procesamiento Accelerator: 1.28.6-gke.1095000 o posterior
    • Para usar la clase de procesamiento Performance: 1.28.6-gke.1369000 y versiones posteriores, o la versión 1.29.1-gke.1575000 y posteriores.

Crea reservas de capacidad para Autopilot

Los Pods de Autopilot pueden consumir reservas que tengan la propiedad de tipo de consumo específica en el mismo proyecto que el clúster o en una reserva compartida de un proyecto diferente. Puedes consumir el hardware reservado si haces referencia de forma explícita a esa reserva en tu manifiesto. Puedes consumir reservas en Autopilot para los siguientes tipos de hardware:

  • Cualquiera de los siguientes tipos de GPU:
    • nvidia-h100-80gb: NVIDIA H100 (80 GB) (solo disponible con la clase de procesamiento Accelerator)
    • nvidia-a100-80gb: NVIDIA A100 (80 GB)
    • nvidia-tesla-a100: NVIDIA A100 (40 GB)
    • nvidia-l4: NVIDIA L4
    • nvidia-tesla-t4: NVIDIA T4

Para crear una reserva de capacidad, consulta los siguientes recursos. La reserva debe cumplir con los siguientes requisitos:

  • Los tipos de máquinas, los tipos de aceleradores y las cantidades de aceleradores coinciden con lo que consumirán tus cargas de trabajo.

  • La reserva usa el tipo de consumo específico. Por ejemplo, en gcloud CLI, debes especificar la marca --require-specific-reservation cuando creas la reserva.

  • Crea una reserva para un solo proyecto

  • Crea una reserva compartida

Consume una reserva específica en el mismo proyecto en Autopilot

En esta sección, se muestra cómo consumir una reserva de capacidad específica que se encuentre en el mismo proyecto que el clúster. Puedes usar kubectl o Terraform.

kubectl

  1. Guarda el siguiente manifiesto como specific-autopilot.yaml. Este manifiesto tiene selectores de nodos que consumen una reserva específica. Puedes usar instancias de VM o aceleradores.

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

    Reemplaza lo siguiente:

    • MACHINE_SERIES: Es una serie de máquina que contiene el tipo de máquina de las VMs en tu reserva de capacidad específica. Por ejemplo, si tu reserva es para tipos de máquina c3-standard-4, especifica C3 en el campo MACHINE_SERIES.
    • RESERVATION_NAME es el nombre de la reserva de capacidad de Compute Engine.

    Aceleradores

      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"
    containers:
    - name: my-container
      image: "k8s.gcr.io/pause"
      resources:
        requests:
          cpu: 12
          memory: "50Gi"
          ephemeral-storage: "200Gi"
        limits:
          nvidia.com/gpu: QUANTITY

    Reemplaza lo siguiente:

    • ACCELERATOR: es el acelerador que reservaste en la reserva de capacidad de Compute Engine. Debe ser uno de los siguientes valores:
      • nvidia-h100-80gb: NVIDIA H100 (80 GB) (solo disponible con la clase de procesamiento Accelerator)
      • nvidia-a100-80gb: NVIDIA A100 (80 GB)
      • nvidia-tesla-a100: NVIDIA A100 (40 GB)
      • nvidia-l4: NVIDIA L4
      • nvidia-tesla-t4: NVIDIA T4
    • RESERVATION_NAME es el nombre de la reserva de capacidad de Compute Engine.
    • QUANTITY: Es la cantidad de GPUs que se deben adjuntar al contenedor. Debe ser una cantidad compatible para la GPU especificada, como se describe en Cantidades de GPU compatibles.

  2. Implementa el Pod:

    kubectl apply -f specific-autopilot.yaml

Autopilot usa la capacidad reservada en la reserva especificada para aprovisionar un nodo nuevo a fin de colocar el Pod.

Terraform

Para consumir una reserva específica en el mismo proyecto con instancias de VM con Terraform, consulta el siguiente ejemplo:

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

Para consumir una reserva específica en el mismo proyecto con la clase de procesamiento de Accelerator mediante Terraform, consulta el siguiente ejemplo:

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

Si deseas obtener más información sobre el uso de Terraform, consulta Compatibilidad con Terraform para GKE.

Consume una reserva compartida específica en Autopilot

En esta sección, se usan los siguientes términos:

  • Proyecto de propietario: el proyecto que posee la reserva y lo comparte con otros proyectos
  • Proyecto de consumidor: el proyecto que ejecuta las cargas de trabajo que consumen la reserva compartida.

Para consumir una reserva compartida, debes otorgar al agente de servicio de GKE acceso a la reserva en el proyecto al que pertenece la reserva. Puedes hacer lo siguiente:

  1. Crea un rol personalizado de IAM que contenga el permiso compute.reservations.list en el proyecto propietario:

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

    Reemplaza lo siguiente:

    • ROLE_NAME: un nombre para tu nuevo rol.
    • OWNER_PROJECT_ID; el ID del proyecto al que pertenece la reserva de capacidad.

  2. Otorga al agente de servicio de GKE en el proyecto de consumidor acceso a la lista de reservas compartidas en el proyecto de propietario:

    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'

    Reemplaza CONSUMER_PROJECT_NUMBER por el número de proyecto numérico de tu proyecto de consumidor. Para encontrar este número, consulta Identifica proyectos en la documentación de Resource Manager.

  3. Guarda el siguiente manifiesto como shared-autopilot.yaml. Este manifiesto tiene nodeSelectors que le indican a GKE que consuma una reserva compartida específica.

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

    Reemplaza lo siguiente:

    • MACHINE_SERIES: Es una serie de máquina que contiene el tipo de máquina de las VMs en tu reserva de capacidad específica. Por ejemplo, si tu reserva es para tipos de máquina c3-standard-4, especifica C3 en el campo MACHINE_SERIES.
    • RESERVATION_NAME es el nombre de la reserva de capacidad de Compute Engine.
    • OWNER_PROJECT_ID; el ID del proyecto al que pertenece la reserva de capacidad.

    Aceleradores

    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

    Reemplaza lo siguiente:

    • ACCELERATOR: es el acelerador que reservaste en la reserva de capacidad de Compute Engine. Debe ser uno de los siguientes valores:
      • nvidia-h100-80gb: NVIDIA H100 (80 GB) (solo disponible con la clase de procesamiento Accelerator)
      • nvidia-a100-80gb: NVIDIA A100 (80 GB)
      • nvidia-tesla-a100: NVIDIA A100 (40 GB)
      • nvidia-l4: NVIDIA L4
      • nvidia-tesla-t4: NVIDIA T4
    • RESERVATION_NAME es el nombre de la reserva de capacidad de Compute Engine.
    • OWNER_PROJECT_ID; el ID del proyecto al que pertenece la reserva de capacidad.
    • QUANTITY: Es la cantidad de GPU que se deben adjuntar al contenedor. Debe ser una cantidad compatible para la GPU especificada, como se describe en Cantidades de GPU compatibles.

  4. Implementa el Pod:

    kubectl apply -f shared-autopilot.yaml

Autopilot usa la capacidad reservada en la reserva especificada para aprovisionar un nodo nuevo a fin de colocar el Pod.

Soluciona problemas relacionados con el consumo de reservas en Autopilot

  • Asegúrate de que los tipos de máquina, los tipos de aceleradores, las configuraciones de SSD locales y las cantidades de aceleradores coincidan con lo que consumirán tus cargas de trabajo. Para obtener una lista completa de las propiedades que deben coincidir, consulta Propiedades de la reserva de capacidad de Compute Engine.
  • Asegúrate de que la reserva se cree con una afinidad específica.
  • Cuando uses reservas compartidas, asegúrate de que el agente de servicio de GKE en el proyecto de consumidor tenga permiso para enumerar las reservas compartidas en el proyecto de propietario.

Consume instancias reservadas en GKE Standard

Cuando creas un clúster o grupo de nodos, puedes especificar la marca --reservation-affinity para indicar el modo de consumo de reserva.

Consume cualquier reserva que coincida

Puedes crear una reserva e instancias para consumir cualquier reserva con gcloud CLI o Terraform.

gcloud

Para consumir automáticamente cualquier reserva que coincida, configura la marca de afinidad de la reserva como --reservation-affinity=any. Dado que any es el valor predeterminado que se define en Compute Engine, puedes omitir completamente la marca de afinidad de la reserva.

En el modo de consumo de reserva any, los nodos primero toman la capacidad de todas las reservas de un solo proyecto antes que de cualquier reserva compartida, ya que las reservas compartidas están más disponibles para otros proyectos. Para obtener más información sobre cómo se consumen las instancias de forma automática, consulta Orden de consumo.

  1. Crea una reserva de tres instancias de VM:

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

    Reemplaza lo siguiente:

    • RESERVATION_NAME: Es el nombre de la reserva que se creará.
    • MACHINE_TYPE: El tipo de máquina (solo nombre) que se usará para la reserva. Por ejemplo, n1-standard-2.

  2. Verifica que se haya creado correctamente la reserva:

    gcloud compute reservations describe RESERVATION_NAME

  3. Crea un clúster que tenga un nodo para que consuma cualquier reserva que coincida:

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

    Reemplaza CLUSTER_NAME por el nombre del clúster que deseas crear.

  4. Crea un grupo de nodos con tres nodos para consumir cualquier reserva coincidente:

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

    Reemplaza NODEPOOL_NAME por el nombre del grupo de nodos que deseas crear.

La cantidad total de nodos es 4, lo que excede la capacidad de la reserva. Por lo tanto, 3 de los nodos consumen la reserva, mientras que el último usa la capacidad del grupo de recursos generales de Compute Engine.

Terraform

Para crear una reserva de tres instancias de VM con Terraform, consulta el siguiente ejemplo:

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

  specific_reservation {
    count = 3

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

Para crear un clúster que tenga un nodo para que consuma cualquier reserva que coincida mediante Terraform, consulta el siguiente ejemplo:

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
}

Para crear un grupo de nodos con tres nodos para consumir cualquier reserva coincidente mediante Terraform, consulta el siguiente ejemplo:

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

Si deseas obtener más información sobre el uso de Terraform, consulta Compatibilidad con Terraform para GKE.

Consume una reserva específica de un solo proyecto

Para consumir una reserva específica, configura la marca de afinidad de reserva como --reservation-affinity=specific y proporciona el nombre de reserva específico. En este modo, las instancias deben consumir la capacidad de la reserva especificada de la zona. La solicitud falla si la reserva no tiene capacidad suficiente.

Para crear una reserva y unas instancias que consuman una reserva específica, haz lo siguiente. Puedes usar gcloud CLI o Terraform.

gcloud

  1. Crea una reserva específica para tres instancias de VM:

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

    Reemplaza lo siguiente:

    • RESERVATION_NAME: Es el nombre de la reserva que se creará.
    • MACHINE_TYPE: El tipo de máquina (solo nombre) que se usará para la reserva. Por ejemplo, n1-standard-2.

  2. Crea un grupo de nodos con un solo nodo para consumir una reserva específica de un solo proyecto:

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

    Reemplaza lo siguiente:

    • NODEPOOL_NAME: el nombre del grupo de nodos que se creará.
    • CLUSTER_NAME: el nombre del clúster que creaste.

Terraform

Para crear una reserva específica con Terraform, consulta el siguiente ejemplo:

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
}

Para crear un grupo de nodos con un solo nodo para consumir una reserva específica de un solo proyecto con Terraform, consulta el siguiente ejemplo:

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

Si deseas obtener más información sobre el uso de Terraform, consulta Compatibilidad con Terraform para GKE.

Consume una reserva compartida específica

Para crear una reserva compartida específica y consumirla, sigue estos pasos. Puedes usar gcloud CLI o Terraform.

  1. Sigue los pasos que se indican en Permite y restringe la creación y la modificación de reservas compartidas para los proyectos.

gcloud

  1. Crea una reserva compartida específica:

    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

    Reemplaza lo siguiente:

    • RESERVATION_NAME: Es el nombre de la reserva que se creará.
    • MACHINE_TYPE: Es el nombre del tipo de máquina que se usará para la reserva. Por ejemplo, n1-standard-2.
    • OWNER_PROJECT_ID: Es el ID del proyecto que deseas que cree esta reserva compartida. Si omites la marca --project, GKE usa el proyecto actual como proyecto propietario de forma predeterminada.
    • CONSUMER_PROJECT_IDS: Es una lista separada por comas de los IDs de los proyectos con los que deseas compartir esta reserva. Por ejemplo, project-1,project-2. Puedes incluir entre 1 y 100 proyectos de consumidor. Estos proyectos deben estar en la misma organización que el proyecto de propietario. No incluyas OWNER_PROJECT_ID, ya que puede consumir esta reserva de forma predeterminada.

  2. Consume la reserva compartida:

      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

    Reemplaza lo siguiente:

    • NODEPOOL_NAME: el nombre del grupo de nodos que se creará.
    • CLUSTER_NAME: el nombre del clúster que creaste.

Terraform

Para crear una reserva compartida específica con Terraform, consulta el siguiente ejemplo:

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
}

Para consumir la reserva compartida específica con Terraform, consulta el siguiente ejemplo:

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

Si deseas obtener más información sobre el uso de Terraform, consulta Compatibilidad con Terraform para GKE.

Consideraciones adicionales sobre el consumo de reservas específicas

Cuando se crea un grupo de nodos con afinidad de reserva específica, incluidos los grupos de nodos predeterminados generados durante la creación de clústeres, su tamaño se limita a la capacidad de la reserva específica para toda la vida útil del grupo de nodos. Esto afecta las siguientes funciones de GKE:

  • Clúster con varias zonas: En clústeres regionales o multizonales, los nodos de un grupo de nodos pueden abarcar varias zonas. Dado que las reservas son de una sola zona, se necesitan varias reservas. Para crear un grupo de nodos que consuma una reserva específica de estos clústeres, debes crear una reserva específica que tenga exactamente el mismo nombre y las mismas propiedades de máquina en cada zona del grupo de nodos.
  • Ajuste de escala automático del clúster y actualizaciones del grupo de nodos: Si no tienes capacidad adicional en la reserva específica, las actualizaciones del grupo de nodos o el ajuste de escala automático del grupo de nodos pueden fallar, ya que ambas operaciones requieren crear instancias adicionales. Para solucionar este problema, puedes cambiar el tamaño de la reserva o liberar algunos de sus recursos limitados.

Crea nodos sin consumir reservas

Para evitar el consumo de recursos de cualquier reserva, configura la afinidad como --reservation-affinity=none.

  1. Crea un clúster que no consuma ninguna reserva:

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

    Reemplaza CLUSTER_NAME por el nombre del clúster que deseas crear.

  2. Crea un grupo de nodos que no consuma ninguna reserva:

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

    Reemplaza NODEPOOL_NAME por el nombre del grupo de nodos que deseas crear.

Sigue las reservas disponibles entre zonas

Cuando usas grupos de nodos que se ejecutan en varias zonas con reservas que no son iguales entre las zonas, puedes usar la marca --location_policy=ANY. Esto garantiza que, cuando se agregan nodos nuevos al clúster, se crean en la zona que aún tiene reservas sin usar.

Reserva de TPU

Las reservas de TPU difieren de otros tipos de máquinas. Los siguientes son aspectos específicos de TPU que debes tener en cuenta cuando crees reservas de TPU:

  • Cuando se usan TPU en GKE, SPECIFIC es el único valor admitido para la marca --reservation-affinity de gcloud container node-pools create.
  • Las reservas de TPU no se pueden compartir entre proyectos.

Para obtener más información, consulta Reservas de TPU.

Realiza una limpieza

Para evitar que se generen cargos en tu cuenta de Facturación de Cloud por los recursos que se usaron en esta página, sigue estos pasos:

  1. Ejecuta el siguiente comando para cada uno de los clústeres a fin de borrar los clústeres que creaste:

    gcloud container clusters delete CLUSTER_NAME

  2. Ejecuta el siguiente comando para cada una de las reservas a fin de borrar las reservas que creaste:

    gcloud compute reservations delete RESERVATION_NAME

¿Qué sigue?