Esta página se ha traducido con Cloud Translation API.

Consumir recursos de zona reservados

Autopilot Standard

En esta página se explica cómo usar recursos de zona de Compute Engine reservados en cargas de trabajo de GKE específicas. Estas reservas de capacidad te ofrecen un alto nivel de garantía 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 el artículo sobre la reserva de recursos de zona de Compute Engine.

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

Operadores de aplicaciones que despliegan cargas de trabajo que deben ejecutarse lo antes posible, normalmente con hardware especializado, como GPUs.
Administradores de plataformas que quieran obtener un alto nivel de garantía de que las cargas de trabajo se ejecutan en hardware optimizado que cumpla 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 zonas, ya sea de forma inmediata o en un momento futuro concreto. Google Cloud Después, puedes usar esta capacidad reservada en GKE.

En función del modo de funcionamiento de GKE, puedes usar los siguientes tipos de reserva:

Modo Autopilot: solo para reservas específicas.
Modo estándar: reservas específicas o cualquier reserva coincidente.

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

Opciones de consumo de reservas en GKE

GKE te permite usar reservas directamente en cargas de trabajo individuales mediante nodeSelectors de Kubernetes en el manifiesto de tu carga de trabajo o creando grupos de nodos en modo Estándar que usen la reserva. En esta página se describe el método para seleccionar directamente reservas en recursos individuales.

También puedes configurar GKE para que consuma reservas durante las operaciones de escalado que creen nodos mediante clases de computación personalizadas. Las clases de computación personalizadas permiten a los administradores de la plataforma definir una jerarquía de configuraciones de nodos para que GKE las priorice durante el escalado 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 cálculo personalizada para que cualquier carga de trabajo de GKE que utilice esa clase de cálculo personalizada indique a GKE que consuma las reservas especificadas para esa clase de cálculo.

Para obtener más información, consulta la sección Consumir reservas de Compute Engine de la página "Acerca de las clases de computación personalizadas".

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la CLI de gcloud, obtén la versión más reciente ejecutando el comando gcloud components update. Es posible que las versiones anteriores de la interfaz de línea de comandos de gcloud no admitan la ejecución de los comandos de este documento.
Nota: Si ya tienes instalada la CLI gcloud, asegúrate de definir la compute/region propiedad. Si usas principalmente clústeres zonales, define compute/zone en su lugar. Si defines una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que tengas que especificar la ubicación en determinados comandos si la ubicación de tu clúster es diferente de la predeterminada que hayas definido.

Consumir reservas de capacidad en clústeres de Autopilot

Los clústeres Autopilot admiten el consumo de recursos de las reservas de capacidad de Compute Engine en el mismo proyecto o en un proyecto compartido. Debe definir la propiedad de tipo de consumo de la reserva de destino como specific y seleccionar explícitamente esa reserva en su manifiesto. Si no especificas una reserva de forma explícita, los clústeres de Autopilot no la consumirán. Para obtener más información sobre los tipos de consumo de reservas, consulta Cómo funcionan las reservas.

Estas reservas cumplen los requisitos para obtener descuentos por compromiso de uso flexibles de Compute. Debes usar la clase de cálculo Accelerator o la clase de cálculo Performance para consumir reservas de capacidad.

Antes de empezar, crea un clúster de Autopilot que ejecute las siguientes versiones:
- Para consumir aceleradores reservados, como GPUs: 1.28.6-gke.1095000 o versiones posteriores
- Para ejecutar pods en una serie de máquinas específica y con cada pod en su propio nodo, utiliza la versión 1.28.6-gke.1369000 o posterior, o la versión 1.29.1-gke.1575000 o posterior.

Crear reservas de capacidad para Autopilot

Los pods de Autopilot pueden consumir reservas que tengan la propiedad de tipo de consumo específico en el mismo proyecto que el clúster o en una reserva compartida de otro proyecto. Puedes usar el hardware reservado haciendo referencia explícita a esa reserva en tu manifiesto. Puedes usar 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: porción de TPU v6e
- tpu-v5p-slice: porción de TPU v5p
- tpu-v5-lite-podslice: porción de pod de TPU v5 Lite
- tpu-v5-lite-device: dispositivo de TPU v5 Lite
- tpu-v4-lite-device: dispositivo de TPU v4 Lite
- tpu-v4-podslice: porción de pod de TPU v4
- tpu-v3-device: dispositivo de TPU v3
- tpu-v3-slice: porción de pod de TPU v3

Para crear una reserva de capacidad, consulta los siguientes recursos. La reserva debe cumplir 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 la CLI de gcloud, debes especificar la marca --require-specific-reservation cuando crees la reserva.
Crear una reserva para un solo proyecto
Crear una reserva compartida

GKE adjunta automáticamente las unidades SSD locales de la reserva específica seleccionada a tu nodo. No es necesario que selecciones SSDs 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 cree a partir de esa reserva tendrán dos SSD locales conectadas.

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

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

kubectl

Guarda el siguiente archivo de 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"
```
Haz los cambios siguientes:
- MACHINE_SERIES: una serie de máquinas que contiene el tipo de máquina de las VMs de tu reserva de capacidad específica. Por ejemplo, si tu reserva es de c3-standard-4 tipos de máquina, especifica c3 en el campo MACHINE_SERIES.
- RESERVATION_NAME: 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
```
Haz los cambios siguientes:
- ACCELERATOR: el acelerador que has reservado 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: el nombre de la reserva de capacidad de Compute Engine.
- QUANTITY: el número de GPUs que se van a asociar al contenedor. Debe ser una cantidad admitida para la GPU especificada, tal como se describe en Cantidades de GPU admitidas.
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
```
Haz los cambios siguientes:
- ACCELERATOR: el acelerador que has reservado en la reserva de capacidad de Compute Engine. Debe ser uno de los siguientes valores:
  - tpu-v6e-slice: porción de TPU v6e
  - tpu-v5p-slice: porción de TPU v5p
  - tpu-v5-lite-podslice: porción de pod de TPU v5 Lite
  - tpu-v5-lite-device: dispositivo de TPU v5 Lite
  - tpu-v4-lite-device: dispositivo de TPU v4 Lite
  - tpu-v4-podslice: porción de pod de TPU v4
  - tpu-v3-device: dispositivo de TPU v3
  - tpu-v3-slice: porción de pod de TPU v3
- TOPOLOGY: la topología de la TPU.
- RESERVATION_NAME: el nombre de la reserva de capacidad de Compute Engine.
- QUANTITY: número de TPUs que se van a asociar al contenedor. Debe estar alineado con la topología de la TPU.

Despliega el pod:

kubectl apply -f specific-autopilot.yaml

Autopilot usa la capacidad reservada en la reserva especificada para aprovisionar un nuevo nodo en el que colocar el pod.

Terraform

Para consumir una reserva específica en el mismo proyecto con instancias de máquina virtual mediante 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 cálculo 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
  ]
}

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

Usar una reserva compartida específica en Autopilot

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

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

Para consumir una reserva compartida, debes conceder acceso a la reserva al agente de servicio de GKE en el proyecto propietario de la reserva. Sigue estos pasos:

Crea un rol de gestión de identidades y accesos personalizado 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'
```
Haz los cambios siguientes:
- ROLE_NAME: el nombre del nuevo rol.
- OWNER_PROJECT_ID: el ID del proyecto que posee la reserva de capacidad.
Da acceso al agente de servicio de GKE en el proyecto de consumidor para que pueda enumerar las reservas compartidas en el proyecto 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'
```
Sustituye CONSUMER_PROJECT_NUMBER por el número de proyecto de tu proyecto de consumidor. Para encontrar este número, consulta el artículo sobre cómo identificar proyectos en la documentación de Resource Manager.
Guarda el siguiente archivo de manifiesto como shared-autopilot.yaml. Este manifiesto tiene nodeSelectors que 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"
```
Haz los cambios siguientes:
- MACHINE_SERIES: una serie de máquinas que contiene el tipo de máquina de las VMs de tu reserva de capacidad específica. Por ejemplo, si tu reserva es para c3-standard-4 tipos de máquina, especifica c3 en el campo MACHINE_SERIES.
- RESERVATION_NAME: el nombre de la reserva de capacidad de Compute Engine.
- OWNER_PROJECT_ID: el ID del proyecto que posee 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
```
Haz los cambios siguientes:
- ACCELERATOR: el acelerador que has reservado 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: el nombre de la reserva de capacidad de Compute Engine.
- OWNER_PROJECT_ID: el ID del proyecto que posee la reserva de capacidad.
- QUANTITY: número de GPUs que se van a asociar al contenedor. Debe ser una cantidad admitida para la GPU especificada, tal como se describe en Cantidades de GPU admitidas.
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
```
Haz los cambios siguientes:
- ACCELERATOR: el acelerador que has reservado en la reserva de capacidad de Compute Engine. Debe ser uno de los siguientes valores:
  - tpu-v6e-slice: porción de TPU v6e
  - tpu-v5p-slice: porción de TPU v5p
  - tpu-v5-lite-podslice: porción de pod de TPU v5 Lite
  - tpu-v5-lite-device: dispositivo de TPU v5 Lite
  - tpu-v4-lite-device: dispositivo de TPU v4 Lite
  - tpu-v4-podslice: porción de pod de TPU v4
  - tpu-v3-device: dispositivo de TPU v3
  - tpu-v3-slice: porción de pod de TPU v3
- TOPOLOGY: la topología de la TPU.
- RESERVATION_NAME: el nombre de la reserva de capacidad de Compute Engine.
- OWNER_PROJECT_ID: el ID del proyecto que posee la reserva de capacidad.
- QUANTITY: número de TPUs que se van a asociar al contenedor. Debe estar alineado con la topología de la TPU.
Despliega el pod:
```
kubectl apply -f shared-autopilot.yaml
```

Autopilot usa la capacidad reservada en la reserva especificada para aprovisionar un nuevo nodo en el que colocar el pod.

Usar un bloque de reserva específico en Autopilot

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

Guarda el siguiente archivo de 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
```
Haz los cambios siguientes:
- ACCELERATOR: el acelerador que has reservado 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: el nombre de la reserva de capacidad de Compute Engine.
- RESERVATION_BLOCKS_NAME: el nombre del bloque de reserva de capacidad de Compute Engine.
- QUANTITY: el número de GPUs que se van a asociar al contenedor. Debe ser una cantidad admitida para la GPU especificada, tal como se describe en Cantidades de GPU admitidas.
En el caso de las reservas que pertenezcan a otro proyecto, añade cloud.google.com/reservation-project: OWNER_PROJECT_ID al campo spec.nodeSelector. Sustituye OWNER_PROJECT_ID por el ID del proyecto propietario de la reserva de capacidad.
Despliega el pod:
```
kubectl apply -f reservation-block-autopilot.yaml
```
Autopilot usa la capacidad reservada del bloque de reserva especificado para aprovisionar un nuevo nodo en el que colocar el pod.

Consumir un subbloque de reserva específico en Autopilot

En esta sección se explica cómo usar un subbloque específico de una reserva de capacidad que esté en el mismo proyecto que tu clúster o en un proyecto compartido.

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
```
Haz los cambios siguientes:
- ACCELERATOR_TYPE: el acelerador que has reservado en la reserva de capacidad de Compute Engine. Este valor debe ser nvidia-gb200.
- ACCELERATOR_COUNT: número de aceleradores que se van a asociar a cada nodo. Este valor debe ser una cantidad admitida para el tipo de acelerador especificado. Para obtener más información, consulta Cantidades de GPU admitidas.
- RESERVATION_NAME: el nombre de la reserva de capacidad de Compute Engine.
- RESERVATION_PROJECT_ID: el ID del proyecto propietario de la reserva de capacidad.
- RESERVATION_BLOCK_NAME: el nombre del bloque de reserva de capacidad de Compute Engine.
- RESERVATION_SUB_BLOCK_NAME: el nombre del subbloque de reserva de capacidad de Compute Engine.

Guarda el siguiente archivo de manifiesto de 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

Sustituye CONTAINER_GPU_COUNT por el número de GPUs que se van a asignar al contenedor. Este valor debe ser igual o inferior al número de aceleradores que la clase de computación asigne a cada nodo.

Despliega el pod:
```
kubectl apply -f reservation-sub-block-pod.yaml
```
Autopilot usa la capacidad reservada del subbloque de reserva especificado para aprovisionar un nuevo nodo en el que ejecutar el pod.

Solucionar problemas al consumir reservas en Autopilot

Asegúrate de que los tipos de máquinas, 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 ver una lista completa de las propiedades que deben coincidir, consulta Propiedades de las reservas 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 del proyecto de consumidor tenga permiso para enumerar las reservas compartidas en el proyecto propietario.

Consumir instancias reservadas en GKE Standard

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

Consumir las reservas coincidentes

Puedes crear una reserva e instancias para consumir cualquier reserva mediante la CLI de gcloud o Terraform.

gcloud

Para consumir automáticamente de cualquier reserva coincidente, asigna el valor --reservation-affinity=any a la marca de afinidad de la reserva. Como any es el valor predeterminado definido en Compute Engine, puedes omitir por completo la marca de afinidad de la reserva.

En el modo de consumo de reservas any, los nodos primero toman capacidad de todas las reservas de un solo proyecto antes 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 automáticamente, consulta Orden de consumo.

Crea una reserva de tres instancias de máquina virtual:
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE --vm-count=3
```
Haz los cambios siguientes:
- RESERVATION_NAME: el nombre de la reserva que se va a crear.
- MACHINE_TYPE: el tipo de máquina (solo el nombre) que se va a usar en la reserva. Por ejemplo, n1-standard-2.

Comprueba que la reserva se haya creado correctamente:

gcloud compute reservations describe RESERVATION_NAME

Crea un clúster con un nodo para consumir cualquier reserva coincidente:

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

Sustituye CLUSTER_NAME por el nombre del clúster que quieras crear.

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

Sustituye NODEPOOL_NAME por el nombre del grupo de nodos que quieras crear.

El número total de nodos es cuatro, lo que supera la capacidad de la reserva. Tres de los nodos consumen la reserva, mientras que el último nodo toma capacidad del grupo de recursos general 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 con un nodo que consuma cualquier reserva coincidente con 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 que consuma cualquier reserva coincidente con 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"
    }
  }
}

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

Consumir una reserva específica de un solo proyecto

Para usar una reserva específica, asigna el valor --reservation-affinity=specific a la marca de afinidad de la reserva y proporciona el nombre de la reserva específica. En este modo, las instancias deben tomar capacidad de la reserva especificada en la zona. La solicitud falla si la reserva no tiene capacidad suficiente.

Para crear una reserva e instancias para consumir una reserva específica, sigue estos pasos. Puedes usar la CLI de gcloud o Terraform.

gcloud

Crea una reserva específica para tres instancias de máquina virtual:
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE --vm-count=3 \
    --require-specific-reservation
```
Haz los cambios siguientes:
- RESERVATION_NAME: el nombre de la reserva que se va a crear.
- MACHINE_TYPE: el tipo de máquina (solo el nombre) que se va a usar en la reserva. Por ejemplo, n1-standard-2.
Crea un grupo de nodos con un solo nodo para consumir una reserva de un solo proyecto específica:
```
gcloud container node-pools create NODEPOOL_NAME \
    --cluster CLUSTER_NAME \
    --machine-type=MACHINE_TYPE --num-nodes=1 \
    --reservation-affinity=specific --reservation=RESERVATION_NAME
```
Haz los cambios siguientes:
- NODEPOOL_NAME: el nombre del grupo de nodos que se va a crear.
- CLUSTER_NAME: el nombre del clúster que has creado.

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 de un solo proyecto 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
  ]
}

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

Consumir una reserva compartida específica

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

Sigue los pasos que se indican en Permitir y restringir que los proyectos creen y modifiquen reservas compartidas.

gcloud

Crear 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
```
Haz los cambios siguientes:
- RESERVATION_NAME: nombre de la reserva que se va a crear.
- MACHINE_TYPE: el nombre del tipo de máquina que se va a usar en la reserva. Por ejemplo, n1-standard-2.
- OWNER_PROJECT_ID: el ID del proyecto en el que quieres crear esta reserva compartida. Si omite la marca --project, GKE usará el proyecto actual como proyecto propietario de forma predeterminada.
- CONSUMER_PROJECT_IDS: lista separada por comas de los IDs de proyecto de los proyectos con los que quieras compartir esta reserva. Por ejemplo, project-1,project-2. Puede incluir entre 1 y 100 proyectos de consumidor. Estos proyectos deben pertenecer a la misma organización que el proyecto propietario. No incluyas OWNER_PROJECT_ID, ya que puede consumir esta reserva de forma predeterminada.

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

Haz los cambios siguientes:

NODEPOOL_NAME: el nombre del grupo de nodos que se va a crear.
CLUSTER_NAME: el nombre del clúster que has creado.

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

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

Consideraciones adicionales para consumir de una reserva específica

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

Clúster con varias zonas: en los clústeres regionales o multizona, los nodos de un grupo de nodos pueden abarcar varias zonas. Como las reservas son zonales, se necesitan varias reservas. Para crear un grupo de nodos que consuma una reserva específica en estos clústeres, debes crear una reserva específica con exactamente el mismo nombre y las mismas propiedades de máquina en cada zona del grupo de nodos.
Autoescalado de clústeres y actualizaciones de grupos de nodos: si no tienes capacidad adicional en la reserva específica, es posible que las actualizaciones de grupos de nodos o el autoescalado de grupos de nodos fallen porque 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.

Consumir reservas de GPU

Para crear un grupo de nodos Estándar que consuma una reserva de GPU o cualquier reserva cuya capacidad se encuentre en una sola zona, debes especificar la marca --node-locations al añadir un grupo de nodos. Cuando creas un clúster Standard regional o un clúster Standard multizonal, especificar las ubicaciones de los nodos asegura 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 el artículo Crear un grupo de nodos con GPUs.

Consumir reservas de TPU

Para crear un grupo de nodos estándar que consuma una reserva de TPU, debes especificar la marca --node-locations al añadir un grupo de nodos. Cuando creas un clúster Standard regional o un clúster Standard multizonal, especificar las ubicaciones de los nodos asegura que GKE cree nodos solo en una zona en la que tengas capacidad de TPU reservada.

Las reservas de TPU son diferentes a las de otros tipos de máquinas. A continuación, se indican los aspectos específicos de las TPU que debes tener en cuenta al crear 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 el artículo Crear un grupo de nodos de TPU.

Crear nodos sin consumir reservas

Para evitar explícitamente el consumo de recursos de cualquier reserva, define la afinidad como --reservation-affinity=none.

Crea un clúster que no consuma ninguna reserva:
```
gcloud container clusters create CLUSTER_NAME --reservation-affinity=none
```
Sustituye CLUSTER_NAME por el nombre del clúster que quieras crear.

Crea un grupo de nodos que no consuma ninguna reserva:

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

Sustituye NODEPOOL_NAME por el nombre del grupo de nodos que quieras crear.

Seguir las reservas disponibles entre zonas

Cuando se usan grupos de nodos que se ejecutan en varias zonas con reservas que no son iguales entre zonas, se puede usar la marca --location_policy=ANY. De esta forma, cuando se añadan nodos al clúster, se crearán en la zona que aún tenga reservas sin usar.

Eliminar los recursos utilizados

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

Elimina los clústeres que has creado ejecutando el siguiente comando para cada uno de ellos:
```
gcloud container clusters delete CLUSTER_NAME
```
Elimina las reservas que has creado ejecutando el siguiente comando para cada una de ellas:
```
gcloud compute reservations delete RESERVATION_NAME
```

Consumir recursos de zona reservados Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Acerca del consumo de reservas en GKE

Opciones de consumo de reservas en GKE

Antes de empezar

Consumir reservas de capacidad en clústeres de Autopilot

Crear reservas de capacidad para Autopilot

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

kubectl

Terraform

Usar una reserva compartida específica en Autopilot

Instancias de VM

Aceleradores de GPU

Aceleradores de TPU

Usar un bloque de reserva específico en Autopilot

Consumir un subbloque de reserva específico en Autopilot

Solucionar problemas al consumir reservas en Autopilot

Consumir instancias reservadas en GKE Standard

Consumir las reservas coincidentes

gcloud

Terraform

Consumir una reserva específica de un solo proyecto

gcloud

Terraform

Consumir una reserva compartida específica

gcloud

Terraform

Consideraciones adicionales para consumir de una reserva específica

Consumir reservas de GPU

Consumir reservas de TPU

Crear nodos sin consumir reservas

Seguir las reservas disponibles entre zonas

Eliminar los recursos utilizados

Siguientes pasos

Consumir recursos de zona reservados