Como consumir recursos por zona reservados

Nesta página, mostramos como consumir recursos zonais reservados do Compute Engine em cargas de trabalho específicas do GKE. Essas reservas de capacidade oferecem um alto nível de garantia de que um hardware específico está disponível para suas cargas de trabalho.

Confira se você já conhece os conceitos de reservas do Compute Engine, como tipos de consumo, compartilhamento e provisionamento. Para mais detalhes, consulte Reservas para recursos zonais do Compute Engine.

Esta página é destinada às seguintes pessoas:

  • Operadores de aplicativos que implantam cargas de trabalho que precisam ser executadas o mais rápido possível, geralmente com hardware especializado, como GPUs.
  • Administradores de plataforma que querem ter um alto nível de garantia de que as cargas de trabalho são executadas em hardware otimizado que atende aos requisitos de aplicativos e da organização.

Sobre o consumo de reservas no GKE

Com as reservas de capacidade do Compute Engine, é possível provisionar configurações de hardware específicas em Google Cloud zonas, imediatamente ou em um horário futuro especificado. Depois, é possível consumir essa capacidade reservada no GKE.

Dependendo do modo de operação do GKE, é possível consumir os seguintes tipos de reserva:

  • Modo Autopilot: apenas reservas específicas.
  • Modo padrão: reservas específicas ou qualquer reserva correspondente.

Para ativar o consumo de reservas e criar recursos, especifique uma afinidade de reserva, como any ou specific.

Opções de consumo de reserva no GKE

O GKE permite consumir reservas diretamente em cargas de trabalho individuais usando nodeSelectors do Kubernetes no manifesto da carga de trabalho ou criando pools de nós do modo Standard que consomem a reserva. Nesta página, descrevemos a abordagem de selecionar diretamente reservas em recursos individuais.

Também é possível configurar o GKE para consumir reservas durante operações de escalonamento que criam novos nós usando classes de computação personalizadas. Com as classes de computação personalizadas, os administradores de plataforma definem uma hierarquia de configurações de nós para o GKE priorizar durante o escalonamento de nós. Assim, as cargas de trabalho são executadas no hardware selecionado.

É possível especificar reservas na configuração da classe de computação personalizada para que qualquer carga de trabalho do GKE que use essa classe indique ao GKE para consumir as reservas especificadas para essa classe.

Para saber mais, na página "Sobre as classes de computação personalizadas", consulte Consumir reservas do Compute Engine.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

  • Ativar a API Google Kubernetes Engine.
    • Ativar a API Google Kubernetes Engine
  • Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e inicialize a gcloud CLI. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da CLI gcloud não sejam compatíveis com a execução dos comandos neste documento.

Consumir reservas de capacidade em clusters do Autopilot

Com os clusters Autopilot, é possível consumir recursos de reservas de capacidade do Compute Engine no mesmo projeto ou em um projeto compartilhado. Defina a property do tipo de consumo da reserva de destino como específico e selecione essa reserva explicitamente no manifesto. Se você não especificar explicitamente uma reserva, os clusters Autopilot não consumirão as reservas. Para saber mais sobre os tipos de consumo de reservas, consulte Como funcionam as reservas.

Essas reservas se qualificam para os descontos por compromisso de uso flexíveis do Compute. Use a classe de computação Accelerator ou Performance para consumir reservas de capacidade.

  • Antes de começar, crie um cluster do Autopilot executando as seguintes versões:

    • Para consumir aceleradores reservados, como GPUs: 1.28.6-gke.1095000 ou mais recente
    • Para executar pods em uma série de máquinas específica e com cada pod em um nó próprio: 1.28.6-gke.1369000 e posterior ou versão 1.29.1-gke.1575000 e posterior.

Criar reservas de capacidade para o Autopilot

Os pods do Autopilot podem consumir reservas com a property do tipo de consumo específico no mesmo projeto que o cluster ou em uma reserva compartilhada de um projeto diferente. Para consumir o hardware reservado, faça referência explícita a essa reserva no manifesto. É possível consumir reservas no Autopilot para os seguintes tipos de hardware:

  • Qualquer um dos seguintes tipos de GPU:

    • nvidia-gb200: NVIDIA GB200 (pré-lançamento)
    • nvidia-b200: NVIDIA B200 (180GB)
    • nvidia-h200-141gb: NVIDIA H200 (141GB)
    • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
    • nvidia-h100-80gb: NVIDIA H100 (80GB)
    • nvidia-a100-80gb: NVIDIA A100 (80GB)
    • nvidia-tesla-a100: NVIDIA A100 (40GB)
    • nvidia-l4: NVIDIA L4
    • nvidia-tesla-t4: NVIDIA T4

  • Qualquer um dos seguintes tipos de TPUs:

    • tpu-v6e-slice: fração de TPU v6e
    • tpu-v5p-slice: fração da TPU v5p
    • tpu-v5-lite-podslice: podslice lite da TPU v5
    • 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 TPU v3
    • tpu-v3-slice: podslice de TPU v3

Para criar uma reserva de capacidade, consulte os recursos a seguir. O bloco precisa atender aos seguintes requisitos:

  • Os tipos de máquina, tipos de acelerador e quantidades de acelerador correspondem ao que suas cargas de trabalho consumirão.

  • A reserva usa o tipo de consumo específico. Por exemplo, na gcloud CLI, é necessário especificar a flag --require-specific-reservation ao criar a reserva.

  • Criar uma reserva para um único projeto

  • Criar uma reserva compartilhada

O GKE anexa automaticamente todos os SSDs locais da reserva específica selecionada ao nó. Não é necessário selecionar SSDs locais individuais no manifesto da carga de trabalho. Por exemplo, se a reserva selecionada incluir dois SSDs locais, os nós que o GKE criar com base nessa reserva terão dois SSDs locais anexados.

Consumir uma reserva específica no mesmo projeto no Autopilot

Nesta seção, mostramos como consumir uma reserva de capacidade específica que está no mesmo projeto que seu cluster. É possível usar o kubectl ou o Terraform.

kubectl

  1. Salve o seguinte manifesto specific-autopilot.yaml como : Esse manifesto tem seletores de nós que consomem uma reserva específica. É possível usar instâncias de VM ou aceleradores.

    Instâncias 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"

    Substitua:

    • MACHINE_SERIES: uma série de máquinas que contém o tipo de máquina das VMs na sua reserva de capacidade específica. Por exemplo, se a reserva for para tipos de máquina c3-standard-4, especifique c3 no campo MACHINE_SERIES.
    • RESERVATION_NAME: o nome da reserva de capacidade do 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

    Substitua:

    • ACCELERATOR: o acelerador que você reservou na reserva de capacidade do Compute Engine. Precisa ser um dos seguintes valores:
      • nvidia-gb200: NVIDIA GB200 (pré-lançamento)
      • nvidia-b200: NVIDIA B200 (180GB)
      • nvidia-h200-141gb: NVIDIA H200 (141GB)
      • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
      • nvidia-h100-80gb: NVIDIA H100 (80GB)
      • nvidia-a100-80gb: NVIDIA A100 (80GB)
      • nvidia-tesla-a100: NVIDIA A100 (40GB)
      • nvidia-l4: NVIDIA L4
      • nvidia-tesla-t4: NVIDIA T4
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • QUANTITY: o número de GPUs a serem anexadas ao contêiner. Precisa ser uma quantidade compatível com a GPU especificada, conforme descrito em Quantidades de GPUs compatíveis.

    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

    Substitua:

    • ACCELERATOR: o acelerador que você reservou na reserva de capacidade do Compute Engine. Precisa ser um dos valores abaixo:
      • tpu-v6e-slice: fração de TPU v6e
      • tpu-v5p-slice: fração da TPU v5p
      • tpu-v5-lite-podslice: podslice lite da TPU v5
      • 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 TPU v3
      • tpu-v3-slice: podslice de TPU v3
    • TOPOLOGY: a topologia da TPU.
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • QUANTITY: o número de TPUs a serem anexadas ao contêiner. Precisa estar alinhado com a topologia de TPU.

  2. Implante o pod:

    kubectl apply -f specific-autopilot.yaml

O Autopilot usa a capacidade reservada na reserva especificada para provisionar um novo nó e posicionar o pod.

Terraform

Para consumir uma reserva específica no mesmo projeto com instâncias de VM usando o Terraform, consulte o exemplo a seguir:

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 uma reserva específica no mesmo projeto com a classe de computação do acelerador usando o Terraform, consulte o exemplo a seguir:

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 saber mais como usar o Terraform, consulte o Suporte do Terraform para GKE.

Consumir uma reserva compartilhada específica no Autopilot

Nesta seção, usamos os seguintes termos:

  • Projeto de proprietário: o projeto que é proprietário da reserva e que a compartilha com outros projetos.
  • Projeto do consumidor: o projeto que executa as cargas de trabalho que consomem a reserva compartilhada.

Para consumir uma reserva compartilhada, você precisa conceder ao agente de serviço do GKE acesso à reserva no projeto que é proprietário dela. Faça o seguinte:

  1. Crie um papel personalizado do IAM que contenha a permissão compute.reservations.list no projeto de proprietário:

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

    Substitua:

    • ROLE_NAME: um nome para a nova função.
    • OWNER_PROJECT_ID: o ID do projeto que tem a reserva de capacidade.

  2. Conceda ao agente de serviço do GKE no projeto consumidor acesso para listar reservas compartilhadas no projeto proprietário:

    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'

    Substitua CONSUMER_PROJECT_NUMBER pelo número de projeto numérico do seu projeto de consumidor. Para encontrar esse número, consulte Como identificar projetos na documentação do Resource Manager.

  3. Salve o seguinte manifesto shared-autopilot.yaml como : Esse manifesto tem nodeSelectors que instruem o GKE a consumir uma reserva compartilhada específica.

    Instâncias 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"

    Substitua:

    • MACHINE_SERIES: uma série de máquinas que contém o tipo de máquina das VMs na sua reserva de capacidade específica. Por exemplo, se a reserva for para tipos de máquina c3-standard-4, especifique c3 no campo MACHINE_SERIES.
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • OWNER_PROJECT_ID: o ID do projeto que tem a reserva de capacidade.

    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

    Substitua:

    • ACCELERATOR: o acelerador que você reservou na reserva de capacidade do Compute Engine. Precisa ser um dos seguintes valores:
      • nvidia-gb200: NVIDIA GB200 (pré-lançamento)
      • nvidia-b200: NVIDIA B200 (180GB)
      • nvidia-h200-141gb: NVIDIA H200 (141GB)
      • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
      • nvidia-h100-80gb: NVIDIA H100 (80GB)
      • nvidia-a100-80gb: NVIDIA A100 (80GB)
      • nvidia-tesla-a100: NVIDIA A100 (40GB)
      • nvidia-l4: NVIDIA L4
      • nvidia-tesla-t4: NVIDIA T4
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • OWNER_PROJECT_ID: o ID do projeto que tem a reserva de capacidade.
    • QUANTITY: o número de GPUs a serem anexadas ao contêiner. Precisa ser uma quantidade compatível com a GPU especificada, conforme descrito em Quantidades de GPUs compatíveis.

    Aceleração com 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

    Substitua:

    • ACCELERATOR: o acelerador que você reservou na reserva de capacidade do Compute Engine. Precisa ser um dos valores abaixo:
      • tpu-v6e-slice: fração de TPU v6e
      • tpu-v5p-slice: fração da TPU v5p
      • tpu-v5-lite-podslice: podslice lite da TPU v5
      • 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 TPU v3
      • tpu-v3-slice: podslice de TPU v3
    • TOPOLOGY: a topologia da TPU.
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • OWNER_PROJECT_ID: o ID do projeto que tem a reserva de capacidade.
    • QUANTITY: o número de TPUs a serem anexadas ao contêiner. Precisa estar alinhado com a topologia de TPU.

  4. Implante o pod:

    kubectl apply -f shared-autopilot.yaml

O Autopilot usa a capacidade reservada na reserva especificada para provisionar um novo nó e posicionar o pod.

Consumir um bloco de reserva específico no Autopilot

Nesta seção, mostramos como consumir um bloco de reserva de capacidade específico que está no mesmo projeto que seu cluster ou em um projeto compartilhado. Esse recurso está disponível apenas para aceleradores específicos. É possível usar kubectl para configurar o pod e consumir o bloco de reserva.

  1. Salve o seguinte manifesto reservation-block-autopilot.yaml como : Esse manifesto tem seletores de nós que consomem uma reserva específica.

    Projeto 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

    Substitua:

    • ACCELERATOR: o acelerador que você reservou na reserva de capacidade do Compute Engine. Precisa ser um dos valores abaixo:
      • nvidia-b200: NVIDIA B200 (180GB)
      • nvidia-h200-141gb: NVIDIA H200 (141GB)
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • RESERVATION_BLOCKS_NAME: o nome do bloco de reserva de capacidade do Compute Engine.
    • QUANTITY: o número de GPUs a serem anexadas ao contêiner. Precisa ser uma quantidade compatível com a GPU especificada, conforme descrito em Quantidades de GPUs compatíveis.

    Para reservas de outro projeto, adicione cloud.google.com/reservation-project: OWNER_PROJECT_ID ao campo spec.nodeSelector. Substitua OWNER_PROJECT_ID pelo ID do projeto que é proprietário da reserva de capacidade.

  2. Implante o pod:

    kubectl apply -f reservation-block-autopilot.yaml

    O Autopilot usa a capacidade reservada no bloco de reserva especificado para provisionar um novo nó e posicionar o pod.

Consumir um sub-bloco de reserva específico no Autopilot

Nesta seção, mostramos como consumir um sub-bloco de reserva de capacidade específico que está no mesmo projeto que seu cluster ou em um projeto compartilhado.

  1. Salve o seguinte manifesto 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

    Substitua:

    • ACCELERATOR_TYPE: o acelerador que você reservou na reserva de capacidade do Compute Engine. Esse valor precisa ser nvidia-gb200.
    • ACCELERATOR_COUNT: o número de aceleradores a serem anexados a cada nó. Esse valor precisa ser uma quantidade compatível com o tipo de acelerador especificado. Para mais informações, consulte Quantidades de GPU compatíveis.
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • RESERVATION_PROJECT_ID: o ID do projeto que tem a reserva de capacidade.
    • RESERVATION_BLOCK_NAME: o nome do bloco de reserva de capacidade do Compute Engine.
    • RESERVATION_SUB_BLOCK_NAME: o nome do sub-bloco da reserva de capacidade do Compute Engine.

  2. Salve o seguinte manifesto 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

    Substitua CONTAINER_GPU_COUNT pelo número de GPUs a serem alocadas para o contêiner. Esse valor precisa ser menor ou igual ao número de aceleradores que a classe de computação anexa a cada nó.

  3. Implante o pod:

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

    O Autopilot usa a capacidade reservada no sub-bloco de reserva especificado para provisionar um novo nó e executar o pod.

Solução de problemas de consumo de reservas no Autopilot

  • Verifique se os tipos de máquina, tipos de acelerador, configurações de SSD local e quantidades de acelerador correspondem ao que suas cargas de trabalho consumirão. Para ver uma lista completa de properties que precisam de correspondência, consulte Properties de reserva de capacidade do Compute Engine.
  • Verifique se a reserva foi criada com afinidade específica.
  • Ao usar reservas compartilhadas, verifique se o agente de serviço do GKE no projeto consumidor tem permissão para listar reservas compartilhadas no projeto proprietário.

Como consumir instâncias reservadas no GKE Standard

Ao criar um cluster ou pool de nós, indique o modo de consumo de reserva especificando a sinalização --reservation-affinity.

Como consumir reservas correspondentes

É possível criar uma reserva e instâncias para consumir qualquer reserva usando a gcloud CLI ou o Terraform.

gcloud

Para consumir automaticamente qualquer reserva correspondente, defina a sinalização de afinidade de reserva como --reservation-affinity=any. Como any é o valor padrão definido no Compute Engine, é possível omitir completamente a flag de afinidade de reserva.

No modo de consumo de reserva any, os nós usam primeiro a capacidade de todas as reservas de projeto único antes das reservas compartilhadas, que estão mais disponíveis para outros projetos. Para saber como as instâncias são consumidas automaticamente, consulte a ordem de consumo.

  1. Crie uma reserva de três instâncias de VM:

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

    Substitua:

    • RESERVATION_NAME: o nome da reserva a ser criada.
    • MACHINE_TYPE: o tipo de máquina (somente nome) a ser usado para a reserva. Por exemplo, n1-standard-2.

  2. Verifique se a reserva foi criada corretamente:

    gcloud compute reservations describe RESERVATION_NAME

  3. Crie um cluster com um nó para consumir qualquer reserva correspondente:

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

    Substitua CLUSTER_NAME pelo nome do cluster a ser criado.

  4. Crie um pool de nós com três nós para consumir qualquer reserva correspondente:

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

    Substitua NODEPOOL_NAME pelo nome do pool de nós a ser criado.

O número total de nós é quatro, o que excede a capacidade da reserva. Três dos nós consomem a reserva enquanto o último nó utiliza o pool geral de recursos do Compute Engine.

Terraform

Para criar uma reserva de três instâncias de VM usando o Terraform, consulte o exemplo a seguir:

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

  specific_reservation {
    count = 3

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

Para criar um cluster com um nó para consumir qualquer reserva correspondente usando o Terraform, consulte o exemplo a seguir:

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 criar um pool de nós com três nós para consumir qualquer reserva correspondente usando o Terraform, consulte o exemplo a seguir:

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 saber mais como usar o Terraform, consulte o Suporte do Terraform para GKE.

Como consumir uma reserva específica de projeto único

Para consumir uma reserva específica, defina a sinalização de afinidade de reserva como --reservation-affinity=specific e informe o nome dessa reserva. Nesse modo, as instâncias precisam usar a capacidade da reserva especificada na zona. A solicitação gerará uma falha se a reserva não tiver capacidade suficiente.

Se quiser criar uma reserva e instâncias para consumir uma reserva específica, siga as etapas abaixo. É possível usar a gcloud CLI ou o Terraform.

gcloud

  1. Crie uma reserva específica de três instâncias de VM:

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

    Substitua:

    • RESERVATION_NAME: o nome da reserva a ser criada.
    • MACHINE_TYPE: o tipo de máquina (somente nome) a ser usado para a reserva. Por exemplo, n1-standard-2.

  2. Crie um pool de nós com um único nó para consumir uma reserva específica de um único projeto:

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

    Substitua:

    • NODEPOOL_NAME: o nome do pool de nós a ser criado.
    • CLUSTER_NAME: o nome do cluster que você criou.

Terraform

Para criar uma reserva específica usando o Terraform, consulte o exemplo a seguir:

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 criar um pool de nós com um único nó para consumir uma reserva específica de um único projeto usando o Terraform, consulte o exemplo a seguir:

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 saber mais como usar o Terraform, consulte o Suporte do Terraform para GKE.

Como consumir uma reserva compartilhada específica

Para criar uma reserva compartilhada específica e consumi-la, siga as etapas abaixo. É possível usar a gcloud CLI ou o Terraform.

  1. Siga as etapas em Como permitir e restringir projetos de criar e modificar reservas compartilhadas.

gcloud

  1. Crie uma reserva compartilhada 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

    Substitua:

    • RESERVATION_NAME: o nome da reserva a ser criada.
    • MACHINE_TYPE: o nome do tipo de máquina a ser usado para a reserva. Por exemplo, n1-standard-2.
    • OWNER_PROJECT_ID: o ID do projeto para o qual essa reserva compartilhada será criada. Se você omitir a flag --project, o GKE usará o projeto atual como proprietário por padrão.
    • CONSUMER_PROJECT_IDS: uma lista separada por vírgulas dos IDs dos projetos com os quais você quer compartilhar essa reserva. Por exemplo, project-1,project-2. É possível incluir de 1 a 100 projetos de consumidor. Esses projetos precisam estar na mesma organização do projeto de proprietário. Não inclua o OWNER_PROJECT_ID, porque ele pode consumir essa reserva por padrão.

  2. Consumir a reserva compartilhada:

      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

    Substitua:

    • NODEPOOL_NAME: o nome do pool de nós a ser criado.
    • CLUSTER_NAME: o nome do cluster que você criou.

Terraform

Para criar uma reserva compartilhada específica usando o Terraform, consulte o exemplo a seguir:

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 a reserva compartilhada específica usando o Terraform, consulte o exemplo a seguir:

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 saber mais como usar o Terraform, consulte o Suporte do Terraform para GKE.

Outras considerações sobre o consumo de uma reserva específica

Quando um pool de nós é criado com uma afinidade específica de reserva, incluindo pools padrão na criação do cluster, o tamanho dele é limitado à capacidade da reserva específica durante todo o ciclo de vida do pool. Isso afeta os seguintes recursos do GKE:

  • Cluster com várias zonas: em clusters regionais ou de várias zonas, os nós de um pool podem se estender por várias zonas. Como as reservas são exclusivas de uma zona, é necessário ter várias reservas. Para ter um pool de nós que consuma a reserva desses clusters, crie uma reserva específica com exatamente os mesmos nome e propriedades de máquina em cada zona do pool.
  • Upgrade automático de clusters e upgrades de pools de nós: se você não tiver capacidade extra na reserva específica, os upgrades de pools de nós ou o escalonamento automático do pool de nós poderão falhar porque as duas operações exigem criação de outras instâncias. Para resolver isso, altere o tamanho da reserva ou libere alguns dos seus recursos limitados.

Como consumir reservas de GPU

Para criar um pool de nós do Standard que consuma uma reserva de GPU ou qualquer reserva em que a capacidade esteja em uma única zona, especifique a flag --node-locations ao adicionar um pool de nós. Ao criar um cluster padrão regional ou um cluster padrão multizonal, especificar os locais dos nós garante que o GKE crie nós apenas em uma zona em que você tenha capacidade de GPU reservada.

Para instruções detalhadas sobre como criar um pool de nós que usa GPUs, consulte Criar um pool de nós de GPU.

Como consumir reservas de TPU

Para criar um pool de nós Standard que consuma uma reserva de TPU, especifique a flag --node-locations ao adicionar um pool de nós. Ao criar um cluster regional do Standard ou um cluster multizonal do Standard, especificar os locais dos nós garante que o GKE crie nós apenas em uma zona em que você reservou capacidade de TPU.

As reservas de TPU são diferentes de outros tipos de máquina. Confira a seguir os aspectos específicos da TPU que precisam ser considerados ao criar reservas de TPU:

  • Ao usar TPUs no GKE, SPECIFIC é o único valor compatível com a flag --reservation-affinity.

Para instruções detalhadas sobre como criar um pool de nós que usa TPUs, consulte Criar um pool de nós de TPU.

Como criar nós sem consumir reservas

Para evitar expressamente o consumo de recursos de qualquer reserva, defina a afinidade como --reservation-affinity=none.

  1. Crie um cluster que não consuma nenhuma reserva:

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

    Substitua CLUSTER_NAME pelo nome do cluster a ser criado.

  2. Crie um pool de nós que não consuma nenhuma reserva:

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

    Substitua NODEPOOL_NAME pelo nome do pool de nós a ser criado.

Como seguir reservas disponíveis entre zonas

Ao usar pools de nós em execução em várias zonas com reservas que não sejam iguais entre zonas, use a sinalização --location_policy=ANY. Isso garante que, quando novos nós forem adicionados ao cluster, eles sejam criados na zona que ainda tem reservas não utilizadas.

Como fazer a limpeza

Para evitar cobranças dos recursos usados nesta página na conta do Google Billing, siga estas etapas:

  1. Exclua os clusters criados executando o seguinte comando para cada um dos clusters:

    gcloud container clusters delete CLUSTER_NAME

  2. Exclua as reservas criadas executando o seguinte comando para cada uma das reservas:

    gcloud compute reservations delete RESERVATION_NAME

A seguir