Consume recursos zonales reservados

En esta página, se muestra cómo consumir recursos zonales reservados de Compute Engine en cargas de trabajo específicas de GKE. Estas reservas de capacidad te brindan un alto nivel de seguridad de que el hardware específico está disponible para tus cargas de trabajo.

Asegúrate de que ya conoces los conceptos de las reservas de Compute Engine, como los tipos de consumo, los tipos de uso compartido y los tipos de aprovisionamiento. Para obtener más información, consulta Reservas de recursos zonales de Compute Engine.

Esta página está destinada a las siguientes personas:

  • Operadores de aplicaciones que implementan cargas de trabajo que deben ejecutarse lo antes posible, por lo general, con hardware especializado, como GPUs.
  • Administradores de plataformas que desean obtener un alto nivel de garantía de que las cargas de trabajo se ejecutan en hardware optimizado que cumple con los requisitos de la aplicación y de la organización.

Acerca del consumo de reservas en GKE

Las reservas de capacidad de Compute Engine te permiten aprovisionar configuraciones de hardware específicas en Google Cloud zonas, ya sea de inmediato o en un momento futuro especificado. Luego, puedes consumir esta capacidad reservada en GKE.

Según el modo de operación de GKE, puedes consumir los siguientes tipos de reservas:

  • Modo Autopilot: Solo reservas específicas.
  • Modo estándar: Reservas específicas o cualquier reserva coincidente

Para habilitar el consumo de reservas para crear tus recursos, debes especificar una afinidad de reserva, como any o specific.

Opciones de consumo de reservas en GKE

GKE te permite consumir reservas directamente en cargas de trabajo individuales usando nodeSelectors de Kubernetes en tu manifiesto de carga de trabajo o creando grupos de nodos en modo estándar que consuman la reserva. En esta página, se describe el enfoque de seleccionar directamente las reservas en recursos individuales.

También puedes configurar GKE para que consuma reservas durante las operaciones de ajuste de escala que crean nodos nuevos con clases de procesamiento personalizadas. Las clases de procesamiento personalizadas permiten que los administradores de la plataforma definan una jerarquía de configuraciones de nodos para que GKE las priorice durante el ajuste de escala de nodos, de modo que las cargas de trabajo se ejecuten en el hardware seleccionado.

Puedes especificar reservas en la configuración de tu clase de procesamiento personalizada para que cualquier carga de trabajo de GKE que use esa clase de procesamiento personalizada le indique a GKE que consuma las reservas especificadas para esa clase de procesamiento.

Para obtener más información, consulta Cómo consumir reservas de Compute Engine en la página "Acerca de las clases de procesamiento personalizadas".

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 el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos que se describen en este documento.

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 de destino en específico y seleccionar explícitamente esa reserva 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, como GPUs: 1.28.6-gke.1095000 o posterior
    • Para ejecutar Pods en una serie de máquinas específica y con cada Pod en su propio nodo: 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 tienen la propiedad de tipo de consumo específico 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-gb200: NVIDIA GB200 (versión preliminar)
    • nvidia-b200: NVIDIA B200 (180 GB)
    • nvidia-h200-141gb: NVIDIA H200 (141 GB)
    • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
    • nvidia-h100-80gb: NVIDIA H100 (80 GB)
    • nvidia-a100-80gb: NVIDIA A100 (80 GB)
    • nvidia-tesla-a100: NVIDIA A100 (40 GB)
    • nvidia-l4: NVIDIA L4
    • nvidia-tesla-t4: NVIDIA T4

  • Cualquiera de los siguientes tipos de TPU:

    • tpu-v6e-slice: Es una porción de TPU v6e.
    • tpu-v5p-slice: Es una porción de TPU v5p.
    • tpu-v5-lite-podslice: Podslice de TPU v5 Lite
    • tpu-v5-lite-device: Dispositivo TPU v5 Lite
    • tpu-v4-lite-device: Dispositivo TPU v4 Lite
    • tpu-v4-podslice: Podslice de TPU v4
    • tpu-v3-device: Dispositivo de TPU v3
    • tpu-v3-slice: Podslice de TPU v3

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

GKE conecta automáticamente cualquier SSD local de la reserva específica seleccionada a tu nodo. No es necesario que selecciones SSD locales individuales en el manifiesto de tu carga de trabajo. Por ejemplo, si la reserva que seleccionas incluye dos SSD locales, los nodos que GKE crea a partir de esa reserva tienen dos SSD locales conectadas.

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: 2
          memory: "4Gi"

    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 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-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-gb200: NVIDIA GB200 (versión preliminar)
      • nvidia-b200: NVIDIA B200 (180 GB)
      • nvidia-h200-141gb: NVIDIA H200 (141 GB)
      • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
      • nvidia-h100-80gb: NVIDIA H100 (80 GB)
      • 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.

    Aceleradores de TPU

      apiVersion: v1
  kind: Pod
  metadata:
    name: specific-same-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-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

    Reemplaza lo siguiente:

    • ACCELERATOR: es el acelerador que reservaste en la reserva de capacidad de Compute Engine. Debe ser uno de los siguientes valores:
      • tpu-v6e-slice: Es una porción de TPU v6e.
      • tpu-v5p-slice: Es una porción de TPU v5p.
      • tpu-v5-lite-podslice: Podslice de TPU v5 Lite
      • tpu-v5-lite-device: Dispositivo TPU v5 Lite
      • tpu-v4-lite-device: Dispositivo TPU v4 Lite
      • tpu-v4-podslice: Podslice de TPU v4
      • tpu-v3-device: Dispositivo de TPU v3
      • tpu-v3-slice: Podslice de TPU v3
    • TOPOLOGY: Es la topología de la TPU.
    • RESERVATION_NAME es el nombre de la reserva de capacidad de Compute Engine.
    • QUANTITY: Es la cantidad de TPU que se deben adjuntar al contenedor. Debe alinearse con la topología de TPU.

  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 para enumerar las 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: 2
        memory: "4Gi"

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

    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-gb200: NVIDIA GB200 (versión preliminar)
      • nvidia-b200: NVIDIA B200 (180 GB)
      • nvidia-h200-141gb: NVIDIA H200 (141 GB)
      • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
      • nvidia-h100-80gb: NVIDIA H100 (80 GB)
      • 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.

    Aceleradores de 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

    Reemplaza lo siguiente:

    • ACCELERATOR: es el acelerador que reservaste en la reserva de capacidad de Compute Engine. Debe ser uno de los siguientes valores:
      • tpu-v6e-slice: Es una porción de TPU v6e.
      • tpu-v5p-slice: Es una porción de TPU v5p.
      • tpu-v5-lite-podslice: Podslice de TPU v5 Lite
      • tpu-v5-lite-device: Dispositivo TPU v5 Lite
      • tpu-v4-lite-device: Dispositivo TPU v4 Lite
      • tpu-v4-podslice: Podslice de TPU v4
      • tpu-v3-device: Dispositivo de TPU v3
      • tpu-v3-slice: Podslice de TPU v3
    • TOPOLOGY: Es la topología de la TPU.
    • 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 TPU que se deben adjuntar al contenedor. Debe alinearse con la topología de TPU.

  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.

Consume un bloque de reserva específico en Autopilot

En esta sección, se muestra cómo consumir un bloque de reserva de capacidad específico que se encuentre en el mismo proyecto que el clúster o en un proyecto compartido. Esta función solo está disponible para aceleradores específicos. Puedes usar kubectl para configurar tu Pod de modo que consuma el bloque de reserva.

  1. Guarda el siguiente manifiesto como reservation-block-autopilot.yaml. Este manifiesto tiene selectores de nodos que consumen una reserva específica.

    Proyecto 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

    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-b200: NVIDIA B200 (180 GB)
      • nvidia-h200-141gb: NVIDIA H200 (141 GB)
    • RESERVATION_NAME es el nombre de la reserva de capacidad de Compute Engine.
    • RESERVATION_BLOCKS_NAME: Es el nombre del bloque de 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.

    Para las reservas que pertenecen a un proyecto diferente, agrega cloud.google.com/reservation-project: OWNER_PROJECT_ID al campo spec.nodeSelector. Reemplaza OWNER_PROJECT_ID por el ID del proyecto propietario de la reserva de capacidad.

  2. Implementa el Pod:

    kubectl apply -f reservation-block-autopilot.yaml

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

Consume un subbloque de reserva específico en Autopilot

En esta sección, se muestra cómo consumir un subbloque de reserva de capacidad específico que se encuentre en el mismo proyecto que el clúster o en un proyecto compartido.

  1. Guarda el siguiente manifiesto de ComputeClass como reservation-sub-block-computeclass.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: specific-reservation-subblock
spec:
  nodePoolAutoCreation:
    enabled: true
  priorities:
  - gpu:
      type: ACCELERATOR_TYPE
      count: ACCELERATOR_COUNT
    reservations:
      affinity: Specific
      specific:
      - name: RESERVATION_NAME
        project: RESERVATION_PROJECT_ID
        reservationBlock:
          name: RESERVATION_BLOCK_NAME
          reservationSubBlock:
            name: RESERVATION_SUB_BLOCK_NAME

    Reemplaza lo siguiente:

    • ACCELERATOR_TYPE: es el acelerador que reservaste en la reserva de capacidad de Compute Engine. Este valor debe ser nvidia-gb200.
    • ACCELERATOR_COUNT: Es la cantidad de aceleradores que se conectarán a cada nodo. Este valor debe ser una cantidad compatible para el tipo de acelerador especificado. Para obtener más información, consulta Cantidades de GPU admitidas.
    • RESERVATION_NAME es el nombre de la reserva de capacidad de Compute Engine.
    • RESERVATION_PROJECT_ID: Es el ID del proyecto al que pertenece la reserva de capacidad.
    • RESERVATION_BLOCK_NAME: Es el nombre del bloque de reserva de capacidad de Compute Engine.
    • RESERVATION_SUB_BLOCK_NAME: Es el nombre del sub-bloque de la reserva de capacidad de Compute Engine.

  2. Guarda el siguiente manifiesto del Pod como reservation-sub-block-pod.yaml:

    apiVersion: v1
kind: Pod
metadata:
  name: reservation-sub-block-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: specific-reservation-subblock
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        cpu: 12
        memory: "50Gi"
        ephemeral-storage: "200Gi"
      limits:
        nvidia.com/gpu: CONTAINER_GPU_COUNT

    Reemplaza CONTAINER_GPU_COUNT por la cantidad de GPUs que se asignarán al contenedor. Este valor debe ser menor o igual que la cantidad de aceleradores que la clase de procesamiento adjunta a cada nodo.

  3. Implementa el Pod:

    kubectl apply -f reservation-sub-block-pod.yaml

    Autopilot usa la capacidad reservada en el subbloque de reserva especificado para aprovisionar un nodo nuevo que ejecute 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 local 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
  ]
}

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.

Cómo consumir reservas de GPU

Para crear un grupo de nodos estándar que consuma una reserva de GPU o cualquier reserva en la que la capacidad se encuentre en una sola zona, debes especificar la marca --node-locations cuando agregues un grupo de nodos. Cuando creas un clúster regional de Standard o un clúster multizonal de Standard, especificar las ubicaciones de los nodos garantiza que GKE cree nodos solo en una zona en la que hayas reservado capacidad de GPU.

Para obtener instrucciones detalladas sobre cómo crear un grupo de nodos que use GPUs, consulta Crea un grupo de nodos de GPU.

Cómo consumir reservas de TPU

Para crear un grupo de nodos estándar que consuma una reserva de TPU, debes especificar la marca --node-locations cuando agregues un grupo de nodos. Cuando creas un clúster regional estándar o un clúster estándar multizonal, especificar las ubicaciones de los nodos garantiza que GKE cree nodos solo en una zona en la que hayas reservado capacidad 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 TPUs en GKE, SPECIFIC es el único valor admitido para la marca --reservation-affinity.

Para obtener instrucciones detalladas sobre cómo crear un grupo de nodos que use TPUs, consulta Crea un nodo TPU TPU.

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.

Realice 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?