Consumir recursos zonais reservados

Esta página mostra como consumir recursos zonais do Compute Engine reservados em cargas de trabalho específicas do GKE. Estas reservas de capacidade dão-lhe um elevado nível de garantia de que o hardware específico está disponível para as suas cargas de trabalho.

Certifique-se de que já conhece os conceitos de reservas do Compute Engine, como tipos de consumo, tipos de partilha e tipos de aprovisionamento. Para ver detalhes, consulte o artigo Reservas de recursos zonais do Compute Engine.

Esta página destina-se às seguintes pessoas:

  • Operadores de aplicações que implementam cargas de trabalho que devem ser executadas assim que possível, normalmente com hardware especializado, como GPUs.
  • Administradores da plataforma que querem obter um elevado nível de garantia de que as cargas de trabalho são executadas em hardware otimizado que cumpre os requisitos da aplicação e da organização.

Acerca do consumo de reservas no GKE

As reservas de capacidade do Compute Engine permitem-lhe aprovisionar configurações de hardware específicas em Google Cloud zonas, imediatamente ou num momento futuro especificado. Em seguida, pode consumir esta capacidade reservada no GKE.

Consoante o modo de funcionamento do GKE, pode consumir os seguintes tipos de reservas:

  • Modo de condução autónoma: apenas reservas específicas.
  • Modo padrão: reservas específicas ou qualquer reserva correspondente.

Para ativar o consumo de reservas para criar os seus recursos, tem de especificar uma afinidade de reserva, como any ou specific.

Opções de consumo de reservas no GKE

O GKE permite-lhe consumir reservas diretamente em cargas de trabalho individuais através da utilização de nodeSelectors do Kubernetes no manifesto da carga de trabalho ou da criação de node pools no modo Standard que consomem a reserva. Esta página descreve a abordagem de selecionar diretamente reservas em recursos individuais.

Também pode configurar o GKE para consumir reservas durante as operações de escalabilidade que criam novos nós através de classes de computação personalizadas. As classes de computação personalizadas permitem que os administradores da plataforma definam uma hierarquia de configurações de nós para o GKE dar prioridade durante o dimensionamento de nós, de modo que as cargas de trabalho sejam executadas no hardware selecionado.

Pode especificar reservas na configuração da classe de computação personalizada para que qualquer carga de trabalho do GKE que use essa classe de computação personalizada indique ao GKE que consuma as reservas especificadas para essa classe de computação.

Para saber mais, na página "Acerca das classes de computação personalizadas", consulte a secção Consuma reservas do Compute Engine.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

  • Ative a API Google Kubernetes Engine.
    • Ative a API Google Kubernetes Engine
  • Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute o comando gcloud components update para obter a versão mais recente. As versões anteriores da CLI gcloud podem não suportar a execução dos comandos neste documento.

Use reservas de capacidade em clusters do Autopilot

Os clusters do Autopilot suportam o consumo de recursos de reservas de capacidade do Compute Engine no mesmo projeto ou num projeto partilhado. Tem de definir a propriedade de tipo de consumo da reserva de destino como específica e tem de selecionar explicitamente essa reserva no seu manifesto. Se não especificar explicitamente uma reserva, os clusters do Autopilot não consomem reservas. Para saber mais sobre os tipos de consumo de reservas, consulte o artigo Como funcionam as reservas.

Estas reservas são elegíveis para descontos por utilização garantida flexíveis de computação. Tem de usar a classe de computação Accelerator ou a classe de computação Performance para consumir reservas de capacidade.

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

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

Crie reservas de capacidade para o Autopilot

Os pods do Autopilot podem consumir reservas que tenham a propriedade do tipo de consumo específica no mesmo projeto que o cluster ou numa reserva partilhada de um projeto diferente. Pode consumir o hardware reservado referenciando explicitamente essa reserva no seu manifesto. Pode usar reservas no Autopilot para os seguintes tipos de hardware:

  • Qualquer um dos seguintes tipos de GPUs:

    • nvidia-gb200: NVIDIA GB200 (pré-visualização)
    • 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: fatia da TPU v6e
    • tpu-v5p-slice: fatia da TPU v5p
    • tpu-v5-lite-podslice: TPU v5 lite podslice
    • tpu-v5-lite-device: dispositivo TPU v5 lite
    • tpu-v4-lite-device: dispositivo TPU v4 lite
    • tpu-v4-podslice: TPU v4 podslice
    • tpu-v3-device: dispositivo TPU v3
    • tpu-v3-slice: TPU v3 podslice

Para criar uma reserva de capacidade, consulte os seguintes recursos. A reserva tem de cumprir os seguintes requisitos:

  • Os tipos de máquinas, os tipos de aceleradores e as quantidades de aceleradores correspondem ao que as suas cargas de trabalho vão consumir.

  • A reserva usa o tipo de consumo específico. Por exemplo, na CLI gcloud, tem de especificar a flag --require-specific-reservation quando cria a reserva.

  • Crie uma reserva para um único projeto

  • Crie uma reserva partilhada

O GKE anexa automaticamente todos os SSDs locais da reserva específica selecionada ao seu nó. Não tem de selecionar SSDs locais individuais no manifesto da carga de trabalho. Por exemplo, se a reserva que selecionar incluir dois SSDs locais, os nós que o GKE cria a partir dessa reserva têm dois SSDs locais anexados.

Use uma reserva específica no mesmo projeto no piloto automático

Esta secção mostra como consumir uma reserva de capacidade específica que se encontra no mesmo projeto que o seu cluster. Pode usar o kubectl ou o Terraform.

kubectl

  1. Guarde o seguinte manifesto como specific-autopilot.yaml. Este manifesto tem seletores de nós que consomem uma reserva específica. Pode 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 o seguinte:

    • 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 sua reserva for para c3-standard-4 tipos de máquinas, 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 o seguinte:

    • ACCELERATOR: o acelerador que reservou na reserva de capacidade do Compute Engine. Tem de ser um dos seguintes valores:
      • nvidia-gb200: NVIDIA GB200 (pré-visualização)
      • 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 associar ao contentor. Tem de ser uma quantidade suportada para a GPU especificada, conforme descrito em Quantidades de GPUs suportadas.

    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 o seguinte:

    • ACCELERATOR: o acelerador que reservou na reserva de capacidade do Compute Engine. Tem de ser um dos seguintes valores:
      • tpu-v6e-slice: fatia da TPU v6e
      • tpu-v5p-slice: fatia da TPU v5p
      • tpu-v5-lite-podslice: TPU v5 lite podslice
      • tpu-v5-lite-device: dispositivo TPU v5 lite
      • tpu-v4-lite-device: dispositivo TPU v4 lite
      • tpu-v4-podslice: TPU v4 podslice
      • tpu-v3-device: dispositivo TPU v3
      • tpu-v3-slice: TPU v3 podslice
    • TOPOLOGY: a topologia da TPU.
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • QUANTITY: o número de TPUs a associar ao contentor. Tem de estar alinhado com a topologia da TPU.

  2. Implemente o agrupamento:

    kubectl apply -f specific-autopilot.yaml

O Autopilot usa a capacidade reservada na reserva especificada para aprovisionar um novo nó para colocar o pod.

Terraform

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

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 seguinte exemplo:

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 sobre a utilização do Terraform, consulte o artigo Compatibilidade do Terraform com o GKE.

Use uma reserva partilhada específica no piloto automático

Esta secção usa os seguintes termos:

  • Projeto proprietário: o projeto que detém a reserva e a partilha com outros projetos.
  • Projeto do consumidor: o projeto que executa as cargas de trabalho que consomem a reserva partilhada.

Para consumir uma reserva partilhada, tem de conceder ao agente do serviço GKE acesso à reserva no projeto que detém a reserva. Faça o seguinte:

  1. Crie uma função de IAM personalizada que contenha a autorização compute.reservations.list no projeto proprietário:

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

    Substitua o seguinte:

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

  2. Conceda ao agente de serviço do GKE no projeto do consumidor acesso à lista de reservas partilhadas 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 numérico do projeto de consumidor. Para encontrar este número, consulte o artigo Identificar projetos na documentação do Resource Manager.

  3. Guarde o seguinte manifesto como shared-autopilot.yaml. Este manifesto tem nodeSelectors que indicam ao GKE para consumir uma reserva partilhada específica.

    Instâncias de VMs

    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 o seguinte:

    • 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 sua reserva for para c3-standard-4 tipos de máquinas, especifique c3 no campo MACHINE_SERIES.
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • OWNER_PROJECT_ID: o ID do projeto do projeto que detém 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 o seguinte:

    • ACCELERATOR: o acelerador que reservou na reserva de capacidade do Compute Engine. Tem de ser um dos seguintes valores:
      • nvidia-gb200: NVIDIA GB200 (pré-visualização)
      • 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 do projeto que detém a reserva de capacidade.
    • QUANTITY: o número de GPUs a associar ao contentor. Tem de ser uma quantidade suportada para a GPU especificada, conforme descrito em Quantidades de GPUs suportadas.

    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

    Substitua o seguinte:

    • ACCELERATOR: o acelerador que reservou na reserva de capacidade do Compute Engine. Tem de ser um dos seguintes valores:
      • tpu-v6e-slice: fatia da TPU v6e
      • tpu-v5p-slice: fatia da TPU v5p
      • tpu-v5-lite-podslice: TPU v5 lite podslice
      • tpu-v5-lite-device: dispositivo TPU v5 lite
      • tpu-v4-lite-device: dispositivo TPU v4 lite
      • tpu-v4-podslice: TPU v4 podslice
      • tpu-v3-device: dispositivo TPU v3
      • tpu-v3-slice: TPU v3 podslice
    • TOPOLOGY: a topologia da TPU.
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • OWNER_PROJECT_ID: o ID do projeto do projeto que detém a reserva de capacidade.
    • QUANTITY: o número de TPUs a associar ao contentor. Tem de estar alinhado com a topologia da TPU.

  4. Implemente o agrupamento:

    kubectl apply -f shared-autopilot.yaml

O Autopilot usa a capacidade reservada na reserva especificada para aprovisionar um novo nó para colocar o pod.

Consuma um bloco de reserva específico no piloto automático

Esta secção mostra como consumir um bloco de reserva de capacidade específico que se encontra no mesmo projeto que o cluster ou num projeto partilhado. Esta funcionalidade só está disponível para aceleradores específicos. Pode usar o kubectl para configurar o seu Pod de forma a consumir o bloco de reserva.

  1. Guarde o seguinte manifesto como reservation-block-autopilot.yaml. Este 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 o seguinte:

    • ACCELERATOR: o acelerador que reservou na reserva de capacidade do Compute Engine. Tem de ser um dos seguintes valores:
      • 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 associar ao contentor. Tem de ser uma quantidade suportada para a GPU especificada, conforme descrito em Quantidades de GPUs suportadas.

    Para reservas pertencentes a um projeto diferente, adicione cloud.google.com/reservation-project: OWNER_PROJECT_ID ao campo spec.nodeSelector. Substitua OWNER_PROJECT_ID pelo ID do projeto do projeto que detém a reserva de capacidade.

  2. Implemente o agrupamento:

    kubectl apply -f reservation-block-autopilot.yaml

    O Autopilot usa a capacidade reservada no bloco de reserva especificado para aprovisionar um novo nó para colocar o pod.

Consuma um sub-bloco de reserva específico no piloto automático

Esta secção mostra como consumir um sub-bloco de reserva de capacidade específico que se encontra no mesmo projeto que o cluster ou num projeto partilhado.

  1. Guarde 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 o seguinte:

    • ACCELERATOR_TYPE: o acelerador que reservou na reserva de capacidade do Compute Engine. Este valor tem de ser nvidia-gb200.
    • ACCELERATOR_COUNT: o número de aceleradores a associar a cada nó. Este valor tem de ser uma quantidade suportada para o tipo de acelerador especificado. Para mais informações, consulte o artigo Quantidades de GPUs suportadas.
    • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.
    • RESERVATION_PROJECT_ID: o ID do projeto do projeto que detém 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 de reserva de capacidade do Compute Engine.

  2. Guarde o seguinte manifesto do agrupamento 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 atribuir ao contentor. Este valor tem de ser inferior ou igual ao número de aceleradores que a classe de computação associa a cada nó.

  3. Implemente o agrupamento:

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

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

Resolução de problemas de consumo de reservas no piloto automático

  • Certifique-se de que os tipos de máquinas, os tipos de aceleradores, as configurações de SSD local e as quantidades de aceleradores correspondem ao que as suas cargas de trabalho vão consumir. Para ver uma lista completa das propriedades que têm de corresponder, consulte as propriedades de reserva de capacidade do Compute Engine.
  • Certifique-se de que a reserva é criada com afinidade específica.
  • Quando usar reservas partilhadas, certifique-se de que o agente do serviço do GKE no projeto do consumidor tem autorização para listar reservas partilhadas no projeto do proprietário.

Consumir instâncias reservadas no GKE Standard

Quando cria um cluster ou um conjunto de nós, pode indicar o modo de consumo da reserva especificando a flag --reservation-affinity.

Consumir quaisquer reservas correspondentes

Pode criar uma reserva e instâncias para consumir qualquer reserva através da CLI gcloud ou do Terraform.

gcloud

Para consumir automaticamente a partir de quaisquer reservas correspondentes, defina a flag de afinidade de reserva como --reservation-affinity=any. Uma vez que any é o valor predefinido definido no Compute Engine, pode omitir completamente a flag de afinidade de reserva.

No anymodo de consumo de reservas, os nós usam primeiro a capacidade de todas as reservas de projeto único antes de qualquer reserva partilhada, porque as reservas partilhadas estão mais disponíveis para outros projetos. Para mais informações sobre como as instâncias são consumidas automaticamente, consulte o artigo 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 o seguinte:

    • RESERVATION_NAME: o nome da reserva a criar.
    • MACHINE_TYPE: o tipo de máquina (apenas o nome) a usar para a reserva. Por exemplo, n1-standard-2.

  2. Verifique se a reserva foi criada com êxito:

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

  4. Crie um node pool 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 conjunto de nós a criar.

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ó usa capacidade do conjunto de recursos geral do Compute Engine.

Terraform

Para criar uma reserva de três instâncias de VM com o Terraform, consulte o seguinte exemplo:

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 seguinte exemplo:

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 node pool com três nós para consumir qualquer reserva correspondente usando o Terraform, consulte o exemplo seguinte:

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 sobre a utilização do Terraform, consulte o artigo Compatibilidade do Terraform com o GKE.

Consumir uma reserva de projeto único específica

Para consumir uma reserva específica, defina a flag de afinidade de reserva como --reservation-affinity=specific e indique o nome da reserva específica. Neste modo, as instâncias têm de usar capacidade da reserva especificada na zona. O pedido falha se a reserva não tiver capacidade suficiente.

Para criar uma reserva e instâncias para consumir uma reserva específica, execute os seguintes passos. Pode usar a CLI gcloud ou o Terraform.

gcloud

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

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

    Substitua o seguinte:

    • RESERVATION_NAME: o nome da reserva a criar.
    • MACHINE_TYPE: o tipo de máquina (apenas o nome) a usar para a reserva. Por exemplo, n1-standard-2.

  2. Crie um node pool com um único nó para consumir uma reserva de projeto único 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

    Substitua o seguinte:

    • NODEPOOL_NAME: o nome do node pool a criar.
    • CLUSTER_NAME: o nome do cluster que criou.

Terraform

Para criar uma reserva específica através do Terraform, consulte o seguinte exemplo:

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 de projeto único específica através do Terraform, consulte o seguinte exemplo:

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 sobre a utilização do Terraform, consulte o artigo Compatibilidade do Terraform com o GKE.

Usar uma reserva partilhada específica

Para criar uma reserva partilhada específica e consumir a reserva partilhada, execute os seguintes passos. Pode usar a CLI gcloud ou o Terraform.

  1. Siga os passos em Permitir e restringir a criação e a modificação de reservas partilhadas por parte de projetos.

gcloud

  1. Crie uma reserva partilhada 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 o seguinte:

    • RESERVATION_NAME: o nome da reserva a criar.
    • MACHINE_TYPE: o nome do tipo de máquina a usar para a reserva. Por exemplo, n1-standard-2.
    • OWNER_PROJECT_ID: o ID do projeto do projeto no qual quer criar esta reserva partilhada. Se omitir a flag --project, o GKE usa o projeto atual como o projeto proprietário por predefinição.
    • CONSUMER_PROJECT_IDS: uma lista separada por vírgulas dos IDs dos projetos com os quais quer partilhar esta reserva. Por exemplo, project-1,project-2. Pode incluir 1 a 100 projetos de consumo. Estes projetos têm de estar na mesma organização que o projeto proprietário. Não inclua o OWNER_PROJECT_ID, porque pode consumir esta reserva por predefinição.

  2. Consumir a reserva partilhada:

      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 o seguinte:

    • NODEPOOL_NAME: o nome do node pool a criar.
    • CLUSTER_NAME: o nome do cluster que criou.

Terraform

Para criar uma reserva partilhada específica com o Terraform, consulte o seguinte exemplo:

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 partilhada específica com o Terraform, consulte o seguinte exemplo:

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 sobre a utilização do Terraform, consulte o artigo Compatibilidade do Terraform com o GKE.

Considerações adicionais para o consumo a partir de uma reserva específica

Quando um conjunto de nós é criado com afinidade de reserva específica, incluindo conjuntos de nós predefinidos durante a criação do cluster, o respetivo tamanho é limitado à capacidade da reserva específica durante todo o ciclo de vida do conjunto de nós. Isto afeta as seguintes funcionalidades do GKE:

  • Cluster com várias zonas: em clusters regionais ou multizonais, os nós de um conjunto de nós podem abranger várias zonas. Como as reservas são de uma única zona, são necessárias várias reservas. Para criar um node pool que consuma uma reserva específica nestes clusters, tem de criar uma reserva específica com exatamente o mesmo nome e propriedades da máquina em cada zona do node pool.
  • Escala automática do cluster e atualizações do node pool: se não tiver capacidade adicional na reserva específica, as atualizações do node pool ou a escala automática do node pool podem falhar, uma vez que ambas as operações requerem a criação de instâncias adicionais. Para resolver esta situação, pode alterar o tamanho da reserva ou libertar alguns dos respetivos recursos limitados.

Consumir reservas de GPU

Para criar um conjunto de nós padrão que consuma uma reserva de GPU ou que consuma qualquer reserva em que a capacidade esteja numa única zona, tem de especificar a flag --node-locations quando adicionar um conjunto de nós. Quando cria um cluster padrão regional ou um cluster padrão multizonal, especificar as localizações dos nós garante que o GKE cria nós apenas numa zona onde tem capacidade de GPU reservada.

Para instruções detalhadas sobre como criar um node pool que usa GPUs, consulte o artigo Crie um node pool de GPU.

Consumir reservas de TPUs

Para criar um node pool padrão que consuma uma reserva de TPU, tem de especificar a flag --node-locations quando adicionar um node pool. Quando cria um cluster Standard regional ou um cluster Standard multizonal, a especificação das localizações dos nós garante que o GKE cria nós apenas numa zona onde reservou capacidade de TPUs.

As reservas de TPUs diferem de outros tipos de máquinas. Seguem-se os aspetos específicos das TPUs que deve considerar ao criar reservas de TPUs:

  • Quando usar TPUs no GKE, SPECIFIC é o único valor suportado para a flag --reservation-affinity.

Para instruções detalhadas sobre como criar um node pool que usa TPUs, consulte o artigo Crie um node pool de TPUs.

Criar nós sem consumir reservas

Para evitar explicitamente o consumo de recursos de quaisquer reservas, 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 criar.

  2. Crie um node pool 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 conjunto de nós a criar.

Seguir as reservas disponíveis entre zonas

Quando usar pools de nós executados em várias zonas com reservas que não são iguais entre zonas, pode usar a flag --location_policy=ANY. Isto garante que, quando são adicionados novos nós ao cluster, estes são criados na zona que ainda tem reservas não usadas.

Limpar

Para evitar incorrer em cobranças na sua conta do Cloud Billing pelos recursos usados nesta página:

  1. Elimine os clusters que criou executando o seguinte comando para cada um dos clusters:

    gcloud container clusters delete CLUSTER_NAME

  2. Elimine as reservas que criou executando o seguinte comando para cada uma das reservas:

    gcloud compute reservations delete RESERVATION_NAME

O que se segue?