Configure a criação automática de node pools

Padrão

Pode reduzir a quantidade de gestão manual de infraestruturas nos clusters padrão do Google Kubernetes Engine (GKE) permitindo que o GKE crie automaticamente node pools para pods pendentes. Este documento mostra como ativar a criação automática de pools de nós para clusters e cargas de trabalho, definir valores predefinidos para nós criados automaticamente e acionar a criação automática para alguns exemplos de utilização comuns.

Este documento destina-se a administradores, operadores e programadores de clusters que gerem infraestrutura e implementam cargas de trabalho em clusters Standard. Para mais informações sobre o funcionamento da criação automática de pools de nós e os diferentes métodos de ativação (como ComputeClasses e aprovisionamento automático de nós ao nível do cluster), consulte o artigo Acerca da criação automática de pools de nós.

Limitações

A criação automática de node pools tem as seguintes limitações:

• Todas as limitações do escalador automático de clusters também se aplicam à criação automática de conjuntos de nós.
• Os clusters com mais de 200 conjuntos de nós totais podem ter uma latência aumentada durante a capacidade de escala automática. Qualquer configuração que acione a criação de um novo conjunto de nós, como a separação de cargas de trabalho ou a utilização de várias ComputeClasses, aumenta este número. Para mais informações sobre os limites de clusters, consulte os limites e as práticas recomendadas em "Planeamento de clusters grandes".
• Todos os limites de recursos que definir para o cluster quando ativar o aprovisionamento automático de nós também se aplicam aos conjuntos de nós que o GKE cria para as ComputeClasses.
• As seguintes definições não são suportadas por ComputeClasses:
  • Atualizações de picos ou atualizações azul-verde.
  • Integridade do nó e arranque seguro.
• Para ativar a criação automática de node pools para uma ComputeClass em versões do GKE anteriores à 1.33.3-gke.1136000, também tem de ativar o aprovisionamento automático de nós ao nível do cluster. Esta limitação não se aplica na versão 1.33.3-gke.1136000 do GKE e posterior.

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.
  Nota: para instalações existentes da CLI gcloud, certifique-se de que define a compute/region propriedade. Se usar principalmente clusters zonais, defina o compute/zone. Ao definir uma localização predefinida, pode evitar erros na CLI gcloud, como os seguintes: One of [--zone, --region] must be supplied: Please specify location. Pode ter de especificar a localização em determinados comandos se a localização do seu cluster for diferente da predefinição que definiu.

Requisitos

Pode ativar a criação automática de pools de nós para todo o cluster em qualquer versão do GKE através da funcionalidade de aprovisionamento automático de nós. Se quiser usar uma ComputeClass para ativar a criação automática de pools de nós ao nível da carga de trabalho e não quiser ativar o aprovisionamento automático de nós, o cluster tem de cumprir os seguintes requisitos:

• Use a versão 1.33.3-gke.1136000 ou posterior do GKE.
• Use o canal de lançamento rápido.

Para acionar a criação automática de pools de nós para configurações de nós específicas, tem de cumprir os requisitos de versão correspondentes. Para mais informações sobre o apoio técnico de versões para várias configurações, consulte as notas de lançamento do GKE (novas funcionalidades) ou a documentação do seu exemplo de utilização.

Ative a criação automática ao nível da carga de trabalho

Pode ativar a criação automática de pools de nós para cargas de trabalho específicas no cluster através de uma ComputeClass. O campo nodePoolAutoCreation numa especificação ComputeClass controla se o GKE pode criar novos conjuntos de nós para pods que selecionem essa ComputeClass. Na versão 1.33.3-gke.1136000 e posteriores do GKE, pode ativar a criação automática de pools de nós para uma ComputeClass, mesmo que o cluster não tenha o aprovisionamento automático de nós ativado. Nas versões anteriores a 1.33.3-gke.1136000, também tem de ativar a administração de contas automática de nós ao nível do cluster.

Para ativar a criação automática do conjunto de nós para uma ComputeClass, siga estes passos:

1. Use um cluster padrão novo ou existente que cumpra os seguintes requisitos:

   • Usa a versão 1.33.3-gke.1136000 ou posterior do GKE.
   • Usa o canal de lançamento rápido.

   Opcionalmente, pode criar um novo cluster padrão.

2. Se o seu cluster não cumprir os requisitos no passo anterior, ative o aprovisionamento automático de nós ao nível do cluster.

3. Guarde o exemplo ComputeClass seguinte como um ficheiro YAML:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     -  machineFamily: n4
     -  machineFamily: n2
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Substitua COMPUTE_CLASS por um nome para a nova ComputeClass. Para mais informações sobre os campos disponíveis em ComputeClasses, consulte a definição de recursos personalizados ComputeClass.

4. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

5. Guarde o exemplo de implementação seguinte, que seleciona uma ComputeClass, como helloweb-deploy.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: helloweb
     labels:
       app: hello
   spec:
     selector:
       matchLabels:
         app: hello
     template:
       metadata:
         labels:
           app: hello
       spec:
         nodeSelector:
           # Replace with the name of a compute class
           cloud.google.com/compute-class: COMPUTE_CLASS 
         containers:
         - name: hello-app
           image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
           ports:
           - containerPort: 8080
           resources:
             requests:
               cpu: "250m"
               memory: "1Gi"

6. Crie a implementação no cluster:

   kubectl apply -f helloweb-deploy.yaml
   

7. Para verificar se o GKE criou um novo conjunto de nós para o seu pod, obtenha uma lista dos conjuntos de nós no seu cluster:

   gcloud container node-pools list \
       --cluster=CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do cluster.
   • CONTROL_PLANE_LOCATION: a região ou a zona do plano de controlo do cluster, como us-central1 ou us-central1-a.

Ative o aprovisionamento automático de nós ao nível do cluster

Para ativar a criação automática de pools de nós para todo o cluster do GKE, use a definição de aprovisionamento automático de nós. O aprovisionamento automático de nós permite que o GKE crie novos node pools para cargas de trabalho pendentes no cluster com base na configuração na especificação do pod ou numa ComputeClass. Pode ativar o aprovisionamento automático de nós para clusters novos ou existentes.

Antes de ativar a administração de contas automática de nós, planeie a dimensão do intervalo de endereços IPv4 principal da sua sub-rede da VPC. O GKE usa este intervalo de endereços IP como o intervalo de endereços IP do nó principal. Consoante a dimensão e a escala do seu cluster, o intervalo de endereços IP dos nós predefinido pode não ter endereços IP suficientes para atribuir a novos nós. Se atualizar o tamanho do intervalo de endereços IP dos nós depois de criar o cluster, tem de atualizar as regras da firewall do cluster do GKE para permitir o tráfego dos novos endereços IP.

Para obter pools de nós criados automaticamente em versões do GKE anteriores a 1.33.3-gke.1136000, tem de seguir os passos nesta secção. Também pode ativar o aprovisionamento automático de nós para um cluster existente editando a configuração do cluster na Google Cloud consola.

Aviso: se ativar o aprovisionamento automático de nós para um cluster existente, as cargas de trabalho pendentes que tenham seletores de nós ou configurações de ComputeClass compatíveis podem acionar a criação automática do conjunto de nós. Valide as especificações da carga de trabalho existentes para minimizar o risco de escalamento automático não intencional.

Para ativar o aprovisionamento automático de nós quando cria um novo cluster, selecione uma das seguintes opções:

Consola

1. Na Google Cloud consola, aceda à página Criar um cluster do Kubernetes.

   Aceda a Crie um cluster do Kubernetes

2. Na página Noções básicas do cluster, especifique um nome e uma localização para o novo cluster.

3. No menu de navegação, clique em Automatização.

4. Selecione a caixa de verificação Ativar aprovisionamento automático de nós. É apresentada uma secção Limites.

5. Especifique limites para a CPU e a memória.

6. Clique em Guardar alterações.

gcloud

gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_MEMORY \
    --max-cpu=MAXIMUM_CPU \
    --max-memory=MAXIMUM_MEMORY \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only

Substitua o seguinte:

• CLUSTER_NAME: o nome do cluster para ativar o aprovisionamento automático de nós.
• CONTROL_PLANE_LOCATION: a região ou a zona do plano de controlo do cluster, como us-central1 ou us-central1-a.
• MINIMUM_CPU: o número mínimo de núcleos no cluster.
• MINIMUM_MEMORY: a capacidade de memória mínima, em GiB, no cluster.
• MAXIMUM_CPU: o número máximo de núcleos no cluster. Este limite aplica-se à soma dos núcleos da CPU em todos os nós novos e existentes no cluster, incluindo os conjuntos de nós criados manualmente.
• MAXIMUM_MEMORY: a capacidade máxima de memória, em GiB, no cluster. Este limite aplica-se à soma da capacidade de memória em todos os conjuntos de nós novos e existentes no cluster, incluindo os conjuntos de nós criados manualmente.

Configure as definições com um ficheiro de configuração do aprovisionamento automático dos nós

Pode configurar os limites de recursos e as definições de configuração dos nós para o aprovisionamento automático de nós através de um ficheiro de configuração YAML. O ficheiro de configuração permite-lhe especificar declarativamente valores predefinidos para conjuntos de nós criados automaticamente e permite-lhe realizar configurações avançadas, como ativar a reparação automática de nós. Este ficheiro não está relacionado com ComputeClasses, que são recursos personalizados do Kubernetes. Em alternativa, o ficheiro de configuração existe como uma alternativa mais extensível à utilização de flags de linha de comando para especificar definições para a administração de contas automática de nós. Para mais informações, consulte o artigo Definições predefinidas ao nível do cluster com um ficheiro de configuração.

Para criar e usar um ficheiro de configuração, siga estes passos:

1. Num editor de texto, crie um ficheiro YAML num caminho ao qual a Google Cloud CLI possa aceder.

2. Adicione as configurações que quer definir ou modificar, como no exemplo seguinte:

   resourceLimits:
     - resourceType: 'cpu'
       minimum: 4
       maximum: 10
     - resourceType: 'memory'
       maximum: 64
     - resourceType: 'nvidia-tesla-t4'
       maximum: 4
   management:
     autoRepair: true
     autoUpgrade: true
   shieldedInstanceConfig:
     enableSecureBoot: true
     enableIntegrityMonitoring: true
   

   Este exemplo tem as seguintes definições para o aprovisionamento automático de nós:

   • resourceLimits: define limites de recursos para a CPU, a capacidade de memória e as GPUs NVIDIA T4 no cluster. Estes limites aplicam-se à soma da capacidade de recursos no cluster, incluindo nos conjuntos de nós criados manualmente.
   • management: ativa a autorreparação de nós e a atualização automática de nós para todos os novos node pools criados automaticamente no cluster.
   • shieldedInstanceConfig: ativa o arranque seguro e a monitorização da integridade dos nós para todos os novos node pools criados automaticamente no cluster.

3. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do cluster.
   • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

Depois de aplicar o ficheiro de configuração ao cluster, o GKE usa as definições no ficheiro para novos conjuntos de nós criados automaticamente no cluster. Estas definições não se aplicam a node pools existentes que o GKE criou no cluster.

Configure limites de recursos para o aprovisionamento automático de nós

Quando usa o aprovisionamento automático de nós ao nível do cluster, tem de configurar limites para a quantidade total de recursos que o cluster pode ter em todos os respetivos conjuntos de nós. Para ativar o aprovisionamento automático de nós para um cluster, tem de especificar limites para a capacidade de CPU e memória no cluster. Além disso, para usar outros tipos de recursos anexados, como GPUs e TPUs, tem de especificar limites para esses recursos. Estes limites só são necessários se ativar a definição de aprovisionamento automático de nós para o seu cluster. Se usar apenas ComputeClasses para obter pools de nós criados automaticamente, não tem de configurar limites de recursos.

Pode adicionar ou modificar os limites de recursos para a criação automática de pools de nós através de um dos seguintes métodos:

• A Google Cloud consola
• Sinalizações da CLI gcloud
• O ficheiro de configuração ao nível do cluster

Para configurar limites de recursos para um cluster existente, selecione uma das seguintes opções:

Consola

1. Na Google Cloud consola, aceda à página Clusters do Kubernetes.

   Aceda aos clusters do Kubernetes

2. Clique no nome do cluster. É apresentada a página Detalhes do cluster.

3. Clique no separador Detalhes.

4. Na secção Automatização, na linha Aprovisionamento automático de nós, clique em Editar. É aberto o painel Editar administração de contas automática de nós.

5. Selecione a caixa de verificação Ativar aprovisionamento automático de nós.

6. Na secção Limites, especifique os valores mínimo e máximo para a capacidade de CPU e de memória no cluster.

7. Para configurar limites para outro recurso, como GPUs ou TPUs, faça o seguinte:

   1. Clique em Adicionar recurso.
   2. Na lista pendente Tipo de recurso, selecione o modelo de GPU ou o tipo de máquina de TPU, como NVIDIA A100 80GB ou ct5p.
   3. Especifique valores mínimos e máximos para o recurso.

8. Opcional: na secção Localizações do conjunto de nós, selecione zonas específicas para o GKE criar nós. Por exemplo, se planear executar cargas de trabalho de GPU, selecione zonas com elevada disponibilidade para o tipo de GPU selecionado.

9. Clique em Guardar alterações.

gcloud

Execute um dos seguintes comandos:

• Especifique os limites de recursos de CPU e memória:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --min-cpu=MINIMUM_CPU \
      --min-memory=MINIMUM_MEMORY \
      --max-cpu=MAXIMUM_CPU \
      --max-memory=MAXIMUM_MEMORY
  

  Substitua o seguinte:

  • MINIMUM_CPU: o número mínimo de núcleos no cluster.
  • MINIMUM_MEMORY: a capacidade de memória mínima, em GiB, no cluster.
  • MAXIMUM_CPU: o número máximo de núcleos no cluster. Este limite aplica-se à soma dos núcleos da CPU em todos os conjuntos de nós no cluster, incluindo os conjuntos de nós criados manualmente.
  • MAXIMUM_MEMORY: a capacidade máxima de memória, em GiB, no cluster. Este limite aplica-se à soma da capacidade de memória em todos os conjuntos de nós no cluster, incluindo os conjuntos de nós criados manualmente.

• Especifique os limites de recursos da GPU:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --min-cpu=MINIMUM_CPU \
      --min-memory=MINIMUM_MEMORY \
      --max-cpu=MAXIMUM_CPU \
      --max-memory=MAXIMUM_MEMORY \
      --min-accelerator=type=GPU_TYPE,count=MINIMUM_GPU_COUNT \
      --max-accelerator=type=GPU_TYPE,count=MAXIMUM_GPU_COUNT
  

  Substitua o seguinte:

  • GPU_TYPE: o tipo de GPU para o qual definir um limite, como nvidia-l4.
  • MINIMUM_GPU_COUNT: o número mínimo de GPUs do tipo especificado que o cluster pode ter.
  • MAXIMUM_GPU_COUNT: o número máximo de GPUs do tipo especificado que o cluster pode ter.

• Especifique os limites de recursos da TPU:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --min-cpu=MINIMUM_CPU \
      --min-memory=MINIMUM_MEMORY \
      --max-cpu=MAXIMUM_CPU \
      --max-memory=MAXIMUM_MEMORY \
      --min-accelerator=type=TPU_TYPE,count=MINIMUM_TPU_COUNT \
      --max-accelerator=type=TPU_TYPE,count=MAXIMUM_TPU_COUNT
  

  Substitua o seguinte:

  • TPU_TYPE: o tipo de TPU para o qual definir um limite. Os seguintes valores são suportados:
    • tpu-v4-podslice: TPU v4.
    • tpu-v5-lite-podslice: TPU v5e com tipos de máquinas que começam por ct5lp-.
    • tpu-v5p-slice: TPU v5e com tipos de máquinas que começam por ct5p-.
    • tpu-v6e-slice: TPU Trillium.
  • MINIMUM_TPU_COUNT: o número mínimo de chips de TPU do tipo especificado que o cluster pode ter. Se o valor que especificar for superior ao número de chips de TPU numa fatia de TPU com vários anfitriões, a fatia de TPU pode não ser reduzida.
  • MAXIMUM_TPU_COUNT: o número máximo de chips de TPU do tipo especificado que o cluster pode ter. Para fatias de TPU com vários anfitriões, especifique um valor superior ao número de chips em cada fatia para que o GKE possa dimensionar a fatia de forma atómica. O número de chips numa fatia é o produto da topologia da TPU. Por exemplo, se a topologia for 2x2x2, o número de chips na fatia é 8, o que significa que o valor de MAXIMUM_TPU_COUNT tem de ser superior a 8.

Ficheiro de configuração

1. No ficheiro de configuração, especifique um dos seguintes conjuntos de campos no campo resourceLimits:

   • Especifique os limites de recursos de CPU e memória:

     resourceLimits:
       - resourceType: 'cpu'
         minimum: MINIMUM_CPU
         maximum: MAXIMUM_CPU
       - resourceType: 'memory'
         minimum: MINIMUM_MEMORY
         maximum: MAXIMUM_MEMORY
     

     Substitua o seguinte:

     • MINIMUM_CPU: o número mínimo de núcleos no cluster.
     • MINIMUM_MEMORY: a capacidade de memória mínima, em GiB, no cluster.
     • MAXIMUM_CPU: o número máximo de núcleos no cluster. Este limite aplica-se à soma dos núcleos da CPU em todos os conjuntos de nós no cluster, incluindo os conjuntos de nós criados manualmente.
     • MAXIMUM_MEMORY: a capacidade máxima de memória, em GiB, no cluster. Este limite aplica-se à soma da capacidade de memória em todos os conjuntos de nós no cluster, incluindo os conjuntos de nós criados manualmente.

   • Especifique os limites de recursos da GPU:

     resourceLimits:
       - resourceType: 'cpu'
         minimum: MINIMUM_CPU
         maximum: MAXIMUM_CPU
       - resourceType: 'memory'
         minimum: MINIMUM_MEMORY
         maximum: MAXIMUM_MEMORY
       - resourceType: 'GPU1_TYPE'
         minimum: MINIMUM_GPU1_COUNT
         maximum: MAXIMUM_GPU1_COUNT
       - resourceType: 'GPU2_TYPE'
         minimum: MINIMUM_GPU2_COUNT
         maximum: MAXIMUM_GPU2_COUNT
     

     Substitua o seguinte:

     • GPU1_TYPE,GPU2_TYPE: os tipos de GPUs para os quais definir limites, como nvidia-l4.
     • MINIMUM_GPU1_COUNT,MINIMUM_GPU2_COUNT: o número mínimo de GPUs dos tipos especificados que o cluster pode ter.
     • MAXIMUM_GPU1_COUNT,MAXIMUM_GPU2_COUNT: o número máximo de GPUs dos tipos especificados que o cluster pode ter.

   • Especifique os limites de recursos da TPU:

     resourceLimits:
       - resourceType: 'cpu'
         minimum: MINIMUM_CPU
         maximum: MAXIMUM_CPU
       - resourceType: 'memory'
         minimum: MINIMUM_MEMORY
         maximum: MAXIMUM_MEMORY
       - resourceType: 'TPU1_TYPE'
         minimum: MINIMUM_TPU1_COUNT
         maximum: MAXIMUM_TPU1_COUNT
       - resourceType: 'TPU2_TYPE'
         minimum: MINIMUM_TPU2_COUNT
         maximum: MAXIMUM_TPU2_COUNT
     

     Substitua o seguinte:

     • TPU1_TYPE,TPU2_TYPE: os tipos de TPUs para os quais definir limites. Os seguintes valores são suportados:
       • tpu-v4-podslice: TPU v4.
       • tpu-v5-lite-podslice: TPU v5e com tipos de máquinas que começam por ct5lp-.
       • tpu-v5p-slice: TPU v5e com tipos de máquinas que começam por ct5p-.
       • tpu-v6e-slice: TPU Trillium.
     • MINIMUM_TPU1_COUNT,MINIMUM_TPU2_COUNT: o número mínimo de chips de TPU do tipo especificado que o cluster pode ter. Se o valor especificado for superior ao número de chips de TPU numa fatia de TPU com vários anfitriões, a fatia de TPU pode não ser reduzida.
     • MAXIMUM_TPU1_COUNT,MAXIMUM_TPU2_COUNT: o número máximo de chips de TPU do tipo especificado que o cluster pode ter. Para fatias de TPU com vários anfitriões, especifique um valor superior ao número de chips em cada fatia para que o GKE possa dimensionar a fatia de forma atómica. O número de chips numa fatia é o produto da topologia da TPU. Por exemplo, se a topologia de TPU1_TYPE for 2x2x2, o número de chips na fatia é 8, o que significa que o valor de MAXIMUM_TPU1_COUNT tem de ser superior a 8.

2. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do cluster.
   • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

Marque os node pools existentes como criados automaticamente

Depois de ativar o aprovisionamento automático de nós ao nível do cluster, pode marcar todos os node pools existentes no cluster como criados automaticamente. O GKE gere o escalamento nestes node pools, incluindo a eliminação dos node pools quando estão vazios. Pode marcar os node pools criados manualmente como criados automaticamente para permitir que o GKE os faça por si.

Se desativar o aprovisionamento automático para o cluster, o GKE deixa de gerir todos os conjuntos de nós criados automaticamente existentes no cluster. Se reativar o aprovisionamento automático para o cluster mais tarde, o GKE não retoma automaticamente a gestão desses conjuntos de nós existentes. Tem de marcar esses node pools existentes como criados automaticamente.

Para marcar um conjunto de nós existente como criado automaticamente, execute o seguinte comando:

gcloud container node-pools update NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning

Substitua NODE_POOL_NAME pelo nome do conjunto de nós.

Configure as predefinições para os conjuntos de nós criados automaticamente

O GKE usa as suas ComputeClasses e especificações de pods para determinar os tipos de nós que podem executar de forma ideal os seus pods pendentes. Opcionalmente, pode configurar as definições predefinidas que o GKE aplica aos conjuntos de nós criados automaticamente, como uma conta de serviço de gestão de identidade e acesso (IAM) personalizada para os nós ou configurações personalizadas do disco de arranque. Estas predefinições substituem todos os valores predefinidos correspondentes que a Google define para os seus clusters. Por exemplo, pode definir uma imagem de nó do Ubuntu como predefinição para os conjuntos de nós criados automaticamente, o que substitui a imagem de nó do SO otimizado para contentores predefinida do GKE.

Pode configurar as predefinições ao nível do cluster através do aprovisionamento automático de nós ou ao nível da carga de trabalho nas ComputeClasses. Antes de configurar uma definição num destes níveis, considere o seguinte:

• As definições ao nível do cluster aplicam-se a qualquer node pool criado automaticamente no cluster e as definições de ComputeClass aplicam-se apenas a cargas de trabalho que usam essa ComputeClass.
• Se especificar a mesma predefinição numa ComputeClass e ao nível do cluster, o GKE usa a definição ComputeClass para cargas de trabalho que usam a ComputeClass.
• Todos os valores predefinidos que configurar aplicam-se apenas a conjuntos de nós criados automaticamente novos. Os conjuntos de nós existentes não são afetados.

As secções seguintes mostram como configurar definições predefinidas específicas.

Defina a imagem do nó predefinida

Selecione uma das seguintes opções:

ComputeClass

1. Num manifesto ComputeClass, use o campo nodePoolConfig.imageType. Este campo está disponível na versão 1.32.4-gke.1198000 e posteriores do GKE.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machineFamily: n4
     - machineFamily: n4d
     nodePoolConfig:
       imageType: IMAGE_TYPE
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Substitua IMAGE_TYPE por um valor para a imagem do nó, que pode ser um dos seguintes:

   • cos_containerd: SO otimizado para contentores com o containerd.
   • ubuntu_containerd: Ubuntu com o containerd.

2. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

gcloud

Para definir a imagem do nó predefinida na linha de comandos, use o sinalizador --autoprovisioning-image-type:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-image-type=IMAGE_TYPE

Substitua o seguinte:

• CLUSTER_NAME: o nome do cluster.
• IMAGE_TYPE: a imagem do nó, que pode ser uma das seguintes:
  • cos_containerd: SO otimizado para contentores com o containerd.
  • ubuntu_containerd: Ubuntu com o containerd.

Para definir a imagem do nó predefinida num ficheiro de configuração, siga estes passos:

1. No ficheiro de configuração, especifique o campo imageType:

     imageType: 'IMAGE_TYPE'
   

   Se o ficheiro de configuração tiver outras definições, não as modifique. Todas as modificações ou remoções no ficheiro de configuração também modificam as definições correspondentes ao nível do cluster.

2. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do cluster.
   • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

Defina a conta de serviço IAM predefinida para nós

Os nós do GKE usam uma conta de serviço do IAM para tarefas do sistema, como registo e monitorização. Para alterar a conta de serviço do IAM para pools de nós criados automaticamente, selecione uma das seguintes opções:

ComputeClass

1. Num manifesto Computeclass, use o campo nodePoolConfig.serviceAccount. Este campo está disponível na versão 1.31.4-gke.1072000 e posteriores do GKE.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machineFamily: n4
     - machineFamily: n4d
     nodePoolConfig:
       serviceAccount: SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Substitua o seguinte:

   • SERVICE_ACCOUNT_NAME: o nome da conta de serviço de IAM, como my-node-account.
   • PROJECT_ID: o ID do projeto da conta de serviço.

2. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

gcloud

Quando usa a CLI gcloud para configurar uma conta de serviço predefinida para pools de nós criados automaticamente, também tem de especificar âmbitos de acesso que os pools de nós requerem para funcionar corretamente.

Para definir a conta de serviço predefinida e os âmbitos de acesso na linha de comandos, use as flags --autoprovisioning-service-account e --autoprovisioning-scopes:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append

Substitua o seguinte:

• SERVICE_ACCOUNT_NAME: o nome da conta de serviço de IAM, como my-node-account.
• PROJECT_ID: o ID do projeto do projeto da conta de serviço.

Para definir a conta de serviço predefinida e os âmbitos de acesso num ficheiro de configuração, siga estes passos:

1. No ficheiro de configuração, especifique os campos serviceAccount e scopes:

   serviceAccount: SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
   scopes: https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append
   

   Se o ficheiro de configuração tiver outras definições, não as modifique. Todas as modificações ou remoções no ficheiro de configuração também modificam as definições correspondentes ao nível do cluster.

2. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do cluster.
   • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

Defina as zonas predefinidas para nós criados automaticamente

Por predefinição, o GKE cria automaticamente nós nas seguintes zonas, dependendo do tipo de cluster:

• Clusters regionais: o GKE cria nós em três zonas aleatórias na região do cluster.
• Clusters zonais: o GKE cria nós na mesma zona que o plano de controlo do cluster.

Pode especificar manualmente uma lista de zonas onde o GKE cria automaticamente nós. Estas zonas têm de estar na mesma região que o plano de controlo do cluster. Por exemplo, se tiver um cluster zonal com o plano de controlo em us-central1-a, pode especificar quaisquer zonas na região us-central1 para que o GKE crie automaticamente nós. Se modificar as zonas predefinidas para nós criados automaticamente num cluster existente, as alterações aplicam-se apenas a novos conjuntos de nós criados pelo GKE.

Para especificar as zonas predefinidas para os nós criados automaticamente, selecione uma das seguintes opções:

ComputeClass

1. Num manifesto ComputeClass, use o campo spec.priorityDefaults.location.zones. Este campo está disponível na versão 1.33.1-gke.1545000 e posteriores do GKE.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorityDefaults:
       location:
         zones: ['ZONE1','ZONE2','...']
     priorities:
     - machineFamily: n4
     - machineFamily: n4d
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Substitua ZONE1,ZONE2,... por uma lista separada por vírgulas das zonas predefinidas para nós criados automaticamente, como "us-central1-a','us-central1-b', 'us-central1-f'". O GKE usa estas zonas se as regras específicas no campo spec.priorities não incluírem uma lista explícita de zonas.

2. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

gcloud

Para definir as zonas predefinidas para a criação automática de conjuntos de nós na linha de comandos, use o sinalizador --autoprovisioning-locations:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-locations=ZONE1,ZONE2,...

Substitua ZONE1,ZONE2,... por uma lista separada por vírgulas das zonas predefinidas para nós criados automaticamente, como "us-central1-a','us-central1-b', 'us-central1-f'".

Para definir as zonas predefinidas para a criação automática de conjuntos de nós através de um ficheiro de configuração, siga estes passos:

1. Especifique o campo autoprovisioningLocations no ficheiro de configuração:

   autoprovisioningLocations:
   - ZONE1
   - ZONE2
   

   Substitua ZONE1,ZONE2 pelos fusos horários predefinidos para nós criados automaticamente, como "us-central1-a" e "us-central1-b".

   Se o ficheiro de configuração tiver outras definições, não as modifique. Todas as modificações ou remoções no ficheiro de configuração também modificam as definições correspondentes ao nível do cluster.

2. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do cluster.
   • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

Defina chaves de encriptação geridas pelo cliente para a encriptação do disco de arranque

Pode especificar uma chave de encriptação gerida pelo cliente (CMEK) no Cloud Key Management Service que o GKE usa para encriptar os discos de arranque dos nós em pools de nós criados automaticamente. Tem de criar a chave antes de a usar com a criação automática do conjunto de nós. Para definir uma CMEK para os discos de arranque dos nós, selecione uma das seguintes opções:

ComputeClass

Em ComputeClasses, tem de especificar a chave em todas as regras de prioridade no campo spec.priorities no ComputeClass.

1. Num manifesto ComputeClass, use o campo priorities.storage.bootDiskKMSKey:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machineFamily: n4
       storage:
         bootDiskKMSKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
     - machineFamily: n4d
       storage:
         bootDiskKMSKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Substitua o seguinte:

   • KEY_PROJECT_ID: o ID do projeto que tem a chave.
   • KEY_LOCATION: a localização do conjunto de chaves.
   • KEY_RING: o nome do conjunto de chaves que contém a chave.
   • KEY_NAME: o nome da chave.

2. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

gcloud

1. Especifique o campo bootDiskKmsKey no ficheiro de configuração:

   bootDiskKmsKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
   

   Substitua o seguinte:

   • KEY_PROJECT_ID: o ID do projeto que tem a chave.
   • KEY_LOCATION: a localização do conjunto de chaves.
   • KEY_RING: o nome do conjunto de chaves que contém a chave.
   • KEY_NAME: o nome da chave.

   Se o ficheiro de configuração tiver outras definições, não as modifique. Todas as modificações ou remoções no ficheiro de configuração também modificam as definições correspondentes ao nível do cluster.

2. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do cluster.
   • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

Configure a integridade dos nós e o arranque seguro

Só pode ativar o arranque seguro e a monitorização da integridade para pools de nós criados automaticamente através do ficheiro de configuração do aprovisionamento automático de nós.

1. Especifique o campo shieldedInstanceConfig no ficheiro de configuração:

   shieldedInstanceConfig:
     enableSecureBoot: true
     enableIntegrityMonitoring: true
   

   Se o ficheiro de configuração tiver outras definições, não as modifique. Todas as modificações ou remoções no ficheiro de configuração também modificam as definições correspondentes ao nível do cluster.

2. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do cluster.
   • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

Configure a autorreparação e a atualização automática de nós

Pode modificar as definições de reparações automáticas de nós e atualizações automáticas de nós em pools de nós criados automaticamente. Estas funcionalidades estão ativadas por predefinição em todos os clusters e conjuntos de nós do GKE. Recomendamos que mantenha estas funcionalidades ativadas para melhorar a fiabilidade e a estabilidade nos seus clusters.

Aviso: a desativação das atualizações automáticas quando o cluster está inscrito num canal de lançamento pode fazer com que o GKE não consiga criar novos node pools.

Para alterar as definições de reparação automática de nós e atualização automática de nós, selecione uma das seguintes opções:

ComputeClass

1. Num manifesto ComputeClass, use o campo autoRepair e o campo autoUpgrade no campo spec.nodePoolConfig. Estes campos estão disponíveis na versão 1.34.0-gke.2201000 e posteriores do GKE.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     nodePoolConfig:
       autoRepair: true
       autoUpgrade: true
     priorities:
     - machineFamily: n4
     - machineFamily: n4d
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

2. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

gcloud

• Para ativar as definições de reparação automática e atualização automática na linha de comandos, use as flags --enable-autoprovisioning-autorepair e --enable-autoprovisioning-autoupgrade:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --enable-autoprovisioning-autorepair \
      --enable-autoprovisioning-autoupgrade
  

• Para desativar as definições de reparação automática e atualização automática na linha de comandos, use as flags --no-enable-autoprovisioning-autorepair e --no-enable-autoprovisioning-autoupgrade:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --no-enable-autoprovisioning-autorepair \
      --no-enable-autoprovisioning-autoupgrade
  

• Para modificar as definições de autorreparação e atualização automática de nós através de um ficheiro de configuração, siga estes passos:

  1. Especifique os campos management.autoRepair e management.autoUpgrade no ficheiro de configuração:

     management:
       autoRepair: true
       autoUpgrade: true
     

     Se o ficheiro de configuração tiver outras definições, não as modifique. Todas as modificações ou remoções no ficheiro de configuração também modificam as definições correspondentes ao nível do cluster.

  2. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

     gcloud container clusters create CLUSTER_NAME \
         --location=CONTROL_PLANE_LOCATION \
         --enable-autoprovisioning \
         --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
     

     Substitua o seguinte:

     • CLUSTER_NAME: o nome do cluster.
     • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

Configure as definições de atualização do aumento

Pode especificar as definições de atualização rápida nos conjuntos de nós criados automaticamente. As atualizações rápidas são a estratégia de atualização de nós do GKE predefinida. Para alterar as definições de atualização por picos, tem de configurar o aprovisionamento automático de nós ao nível do cluster.

• Para especificar as definições de atualização de picos na linha de comandos, use as flags --autoprovisioning-max-surge-upgrade e --autoprovisioning-max-unavailable-upgrade:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --autoprovisioning-max-surge-upgrade=MAX_SURGE \
      --autoprovisioning-max-unavailable-upgrade=MAX_UNAVAILABLE
  

  Substitua o seguinte:

  • MAX_SURGE: o número máximo de nós que podem ser adicionados ao conjunto de nós durante as atualizações.
  • MAX_UNAVAILABLE: o número máximo de nós no node pool que podem estar simultaneamente indisponíveis durante as atualizações.

• Para especificar as definições de atualização de picos usando um ficheiro de configuração, siga estes passos:

  1. Especifique os campos upgradeSettings.maxSurgeUpgrade e upgradeSettings.maxUnavailableUpgrade no ficheiro de configuração:

     upgradeSettings:
       maxSurgeUpgrade: MAX_SURGE
       maxUnavailableUpgrade: MAX_UNAVAILABLE
     

     Se o ficheiro de configuração tiver outras definições, não as modifique. Todas as modificações ou remoções no ficheiro de configuração também modificam as definições correspondentes ao nível do cluster.

  2. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

     gcloud container clusters create CLUSTER_NAME \
         --location=CONTROL_PLANE_LOCATION \
         --enable-autoprovisioning \
         --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
     

     Substitua o seguinte:

     • CLUSTER_NAME: o nome do cluster.
     • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

As definições de atualização rápida que especificar aplicam-se apenas se o cluster usar atualizações rápidas para atualizar pools de nós criados automaticamente. Para mudar a estratégia de atualização de nós para atualizações rápidas para novos conjuntos de nós criados automaticamente, execute o seguinte comando:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --enable-autoprovisioning-surge-upgrade

Quando muda a estratégia de atualização, o GKE usa todas as definições que configurou anteriormente para essa estratégia de atualização.

Use atualizações azul-verde para novos node pools criados automaticamente

Pode mudar a estratégia de atualização de nós para atualizações azul-verde para todos os novos conjuntos de nós criados automaticamente e ajustar as predefinições para atualizações azul-verde. Para alterar a estratégia de atualização, tem de configurar o aprovisionamento automático de nós ao nível do cluster. As alterações que fizer aplicam-se apenas aos novos conjuntos de nós criados automaticamente. Também pode atualizar os conjuntos de nós criados automaticamente existentes para usar atualizações azul-verde.

• Para usar atualizações azul/verde e as predefinições do GKE para novos conjuntos de nós criados automaticamente, execute o seguinte comando:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION
      --enable-autoprovisioning \
      --enable-autoprovisioning-blue-green-upgrade
  

• Para usar atualizações azul/verde e configurar as suas próprias predefinições para novos pools de nós criados automaticamente, execute o seguinte comando:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --enable-autoprovisioning-blue-green-upgrade \
      --autoprovisioning-node-pool-soak-duration=NODE_POOL_SOAK_DURATION \
      --autoprovisioning-standard-rollout-policy=batch-node-count=BATCH_NODE_COUNT,batch-soak-duration=BATCH_SOAK_DURATION
  

  Substitua o seguinte:

  • NODE_POOL_SOAK_DURATION: a duração, em segundos, que o GKE aguarda após esvaziar todos os lotes de nós no conjunto azul antes de eliminar o conjunto azul. O valor predefinido é 3600.
  • BATCH_NODE_COUNT: o número de nós a esvaziar num lote durante a fase de esvaziamento do conjunto azul. O valor predefinido é 1. Se especificar um valor de 0, o GKE ignora a fase de esgotamento do conjunto azul.
  • BATCH_SOAK_DURATION: a duração, em segundos, que o GKE aguarda para iniciar uma operação de drenagem em lote após a conclusão da operação de drenagem anterior. O valor predefinido é 0.

Configure discos de arranque de nós personalizados

Para especificar o tipo e o tamanho dos discos de arranque que o GKE anexa a cada VM de nó num conjunto de nós criado automaticamente, selecione uma das seguintes opções:

ComputeClass

1. Use os campos bootDiskType e bootDiskSize no campo spec.priorities.storage num ComputeClass:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machineFamily: n4
       storage:
         bootDiskType: BOOT_DISK_TYPE
         bootDiskSize: BOOT_DISK_SIZE
     - machineFamily: n4d
       storage:
         bootDiskType: BOOT_DISK_TYPE
         bootDiskSize: BOOT_DISK_SIZE
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Substitua o seguinte:

   • BOOT_DISK_TYPE: o tipo de disco a usar como disco de arranque do nó. O valor que especificar tem de ser suportado pelo tipo de máquina do Compute Engine que o GKE usa para essa regra de prioridade. O valor tem de ser um dos seguintes:
     • pd-balanced: disco persistente equilibrado.
     • pd-standard: disco persistente padrão.
     • pd-ssd: desempenho (SSD) Persistent Disk.
     • hyperdisk-balanced: Google Cloud Hyperdisk Balanced.
   • BOOT_DISK_SIZE: o tamanho, em GiB, do disco de arranque do nó. O valor mínimo é 10.

2. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

gcloud

1. No ficheiro de configuração, especifique os campos diskSizeGb e diskType:

   diskSizeGb: BOOT_DISK_SIZE
   diskType: BOOT_DISK_TYPE
   

   Substitua o seguinte:

   • BOOT_DISK_TYPE: o tipo de disco a usar como disco de arranque do nó. O valor que especificar tem de ser suportado pelo tipo de máquina do Compute Engine que o GKE usa para essa regra de prioridade. O valor tem de ser um dos seguintes:
     • pd-balanced: disco persistente equilibrado.
     • pd-standard: disco persistente padrão.
     • pd-ssd: desempenho (SSD) Persistent Disk.
     • hyperdisk-balanced: Google Cloud Hyperdisk Balanced.
   • BOOT_DISK_SIZE: o tamanho, em GiB, do disco de arranque do nó. O valor mínimo é 10.

   Se o ficheiro de configuração tiver outras definições, não as modifique. Todas as modificações ou remoções no ficheiro de configuração também modificam as definições correspondentes ao nível do cluster.

2. Faculte o ficheiro de configuração ao GKE especificando o sinalizador --autoprovisioning-config-file e o sinalizador --enable-autoprovisioning para um cluster novo ou existente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Substitua o seguinte:

   • CLUSTER_NAME: o nome do cluster.
   • PATH_TO_CONFIGURATION_FILE: o caminho para o ficheiro de configuração.

O GKE reserva uma parte do disco de arranque do nó para a funcionalidade do sistema e para o armazenamento efémero. Para mais informações, consulte o artigo Armazenamento efémero suportado pelo disco de arranque do nó.

Configure node pools criados automaticamente para cenários comuns

As secções seguintes mostram como pedir pools de nós criados automaticamente para determinados casos de utilização comuns do GKE. Para mais informações sobre exemplos de utilização adicionais e configurações suportadas, consulte a documentação do seu exemplo de utilização específico.

Selecione uma série de máquinas ou um tipo de máquina

Para selecionar uma série de máquinas ou um tipo de máquina do Compute Engine suportado, selecione uma das seguintes opções:

ComputeClass

1. Num manifesto ComputeClass, especifique um dos seguintes campos no campo spec.priorities. Pode especificar ambos os campos no mesmo manifesto de ComputeClass, mas não na mesma regra de prioridade.

   • Para selecionar uma série de máquinas, especifique o campo machineFamily numa regra de prioridade:

     apiVersion: cloud.google.com/v1
     kind: ComputeClass
     metadata:
       name: COMPUTE_CLASS
     spec:
       priorities:
       - machineFamily: MACHINE_SERIES
       whenUnsatisfiable: ScaleUpAnyway
       nodePoolAutoCreation:
         enabled: true
     

     Substitua MACHINE_SERIES por uma série de máquinas do Compute Engine, como n4.

   • Para selecionar um tipo de máquina, especifique o campo machineType numa regra de prioridade:

     apiVersion: cloud.google.com/v1
     kind: ComputeClass
     metadata:
       name: COMPUTE_CLASS
     spec:
       priorities:
       - machineType: MACHINE_TYPE
       whenUnsatisfiable: ScaleUpAnyway
       nodePoolAutoCreation:
         enabled: true
     

     Substitua MACHINE_TYPE por um tipo de máquina do Compute Engine, como c4-standard-96. Na versão 1.33.2-gke.1111000 e posteriores do GKE, também pode especificar tipos de máquinas personalizados neste campo.

   Não pode especificar o campo machineFamily e o campo machineType na mesma regra de prioridade.

2. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

3. Selecione a ComputeClass numa carga de trabalho.

Especificação do agrupamento

1. Num manifesto de Pod, selecione uma das seguintes etiquetas de nó:

   • Para selecionar uma série de máquinas, use a cloud.google.com/machine-familyetiqueta de nó:

     apiVersion: v1
     kind: Pod
     metadata:
       name: machine-series-pod
     spec:
       nodeSelector:
         cloud.google.com/machine-family: MACHINE_SERIES
       containers:
       - name: hello-app
         image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
     

     Substitua MACHINE_SERIES por uma série de máquinas do Compute Engine, como n4.

   • Para selecionar um tipo de máquina predefinido, use as etiquetas de nós cloud.google.com/machine-family e node.kubernetes.io/instance-type:

     apiVersion: v1
     kind: Pod
     metadata:
       name: machine-series-pod
     spec:
       nodeSelector:
         cloud.google.com/machine-family: MACHINE_SERIES
         node.kubernetes.io/instance-type: MACHINE_TYPE
       containers:
       - name: hello-app
         image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
     

     Substitua MACHINE_TYPE por um tipo de máquina do Compute Engine na série de máquinas especificada. Por exemplo, se especificar n4 para MACHINE_SERIES, pode especificar n4-standard-80 para MACHINE_TYPE.

     Na versão 1.33.2-gke.1111000 do GKE, também pode especificar tipos de máquinas personalizados neste campo.

2. Crie o grupo:

   kubectl apply -f PATH_TO_POD_MANIFEST
   

   Substitua PATH_TO_POD_MANIFEST pelo caminho para o manifesto do pod.

Selecionar GPUs

Para pedir GPUs para pools de nós criados automaticamente, selecione uma das seguintes opções:

ComputeClass

1. Num manifesto ComputeClass, especifique o campo spec.priorities.gpu:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - gpu:
         type: GPU_TYPE
         count: GPU_COUNT
         driverVersion: DRIVER_VERSION
     whenUnsatisfiable: DoNotScaleUp
     nodePoolAutoCreation:
       enabled: true
   

   Substitua o seguinte:

   • GPU_TYPE: o tipo de GPU a associar, como nvidia-l4.
   • GPU_COUNT: o número de GPUs a associar a cada nó. Este valor tem de ser, pelo menos, 1.
   • DRIVER_VERSION: a versão do controlador da GPU a instalar. Este valor tem de ser default ou latest. Este campo requer a versão 1.31.1-gke.1858000 ou posterior do GKE.

2. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

3. Selecione a ComputeClass numa carga de trabalho de GPU, como no exemplo seguinte:

   apiVersion: v1
   kind: Pod
   metadata:
     name: my-gpu-pod
   spec:
     nodeSelector:
       cloud.google.com/compute-class: nvidia-l4-class
     containers:
     - name: my-gpu-container
       image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
       command: ["/bin/bash", "-c", "--"]
       args: ["while true; do sleep 600; done;"]
       resources:
         limits:
         nvidia.com/gpu: 1
   

Especificação do agrupamento

Para selecionar GPUs nas especificações do pod, tem de configurar o aprovisionamento automático de nós ao nível do cluster e definir limites de recursos para esse tipo de GPU. Para configurar os limites de recursos da GPU e selecionar GPUs nos seus pods, siga estes passos:

1. Configure os limites de recursos ao nível do cluster para as GPUs que quer usar, conforme descrito na secção Configure limites de recursos para a criação automática de conjuntos de nós.

2. Selecione GPUs através da utilização de etiquetas de nós na especificação do pod:

   apiVersion: v1
   kind: Pod
   metadata:
     name: my-gpu-pod
   spec:
     nodeSelector:
       cloud.google.com/gke-accelerator: GPU_TYPE
       cloud.google.com/gke-accelerator-count: GPU_COUNT
       cloud.google.com/gke-gpu-driver-version: DRIVER_VERSION
     containers:
     - name: my-gpu-container
       image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
       command: ["/bin/bash", "-c", "--"]
       args: ["while true; do sleep 600; done;"]
       resources:
         limits:
         nvidia.com/gpu: GPU_QUANTITY
   

   Substitua o seguinte:

   • GPU_TYPE: o tipo de GPU a associar, como nvidia-l4.
   • GPU_COUNT: o número de GPUs a associar a cada nó. Este valor tem de ser, pelo menos, 1.
   • DRIVER_VERSION: a versão do controlador da GPU a instalar. Este valor tem de ser default ou latest. Na versão 1.32.2-gke.1297000 e posteriores do GKE, o GKE instala automaticamente a versão do controlador default. Esta etiqueta de nó requer a versão 1.29.2-gke.1108000 ou posterior do GKE. Para mais informações, consulte o artigo Instalar controladores através do aprovisionamento automático de nós com GPUs.
   • GPU_QUANTITY: o número de GPUs a associar ao agrupamento. Este valor tem de ser inferior ou igual ao valor de GPU_COUNT.

Selecione TPUs

Pode pedir TPUs em ComputeClasses ou especificações de pods. Esta secção pressupõe que conhece a seleção do Cloud TPU e que sabe o tipo, a topologia e a quantidade de TPUs que quer usar. Os passos que segue dependem da forma como seleciona as TPUs:

• ComputeClasses: consulte o artigo Aprovisione TPUs através de classes de computação personalizadas.
• Especificação do agrupamento:
  1. Configure os limites de recursos ao nível do cluster para as UTPs que quer usar, conforme descrito na secção Configure os limites de recursos para a criação automática de conjuntos de nós.
  2. Configure os seletores e os pedidos de recursos nas especificações do pod, conforme descrito no artigo Execute a sua carga de trabalho em nós de fatia de TPU.

Limite o tempo de execução dos nós criados automaticamente

Pode especificar uma duração máxima após a qual o GKE termina os nós criados automaticamente. As restrições do Compute Engine aplicam-se a este limite de tempo.

Selecione uma das seguintes opções:

ComputeClass

1. Num manifesto ComputeClass, use o campo spec.priorities.maxRunDurationSeconds. Este campo está disponível na versão 1.32.1-gke.1159000 e posteriores do GKE.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machine-family: n4
       maxRunDurationSeconds: MAX_RUN_DURATION
     whenUnsatisfiable: DoNotScaleUp
     nodePoolAutoCreation:
       enabled: true
   

   Substitua MAX_RUN_DURATION pelo tempo, em segundos, que os nós criados automaticamente podem ser executados antes de o GKE terminar os nós.

2. Aplique o manifesto ComputeClass ao cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho para o ficheiro de manifesto da ComputeClass.

3. Selecione a ComputeClass numa carga de trabalho.

Especificação do agrupamento

1. No manifesto do agrupamento, use um seletor de nós para a etiqueta do nó cloud.google.com/gke-max-run-duration-seconds. Esta etiqueta de nó está disponível na versão 1.31.2-gke.1518000 do GKE e posterior.

   apiVersion: v1
   kind: Pod
   metadata:
     name: machine-series-pod
   spec:
     nodeSelector:
       cloud.google.com/machine-family: n4
       cloud.google.com/gke-max-run-duration-seconds: MAX_RUN_DURATION
     containers:
     - name: hello-app
       image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
   

   Substitua MAX_RUN_DURATION pelo tempo, em segundos, que os nós criados automaticamente podem ser executados antes de o GKE terminar os nós.

2. Crie o grupo:

   kubectl apply -f PATH_TO_POD_MANIFEST
   

   Substitua PATH_TO_POD_MANIFEST pelo caminho para o manifesto do pod.

Especifique uma plataforma de CPU mínima

O aprovisionamento automático de nós suporta a criação de conjuntos de nós com uma plataforma de CPU mínima especificada. Pode especificar a plataforma de CPU mínima ao nível da carga de trabalho (recomendado) ou ao nível do cluster.

Desative a criação automática de node pools

As secções seguintes mostram como desativar a criação automática de pools de nós para pools de nós específicos ou para todo o cluster. Também pode desativar a criação automática de node pools numa ComputeClass especificando um valor de false no campo nodePoolAutoCreation.enabled da ComputeClass. No entanto, não recomendamos que desative a criação automática para ComputeClasses, porque a criação automática é uma das principais vantagens das ComputeClasses que lhe permite usar funcionalidades como a migração ativa e as prioridades de alternativa.

Desative a criação automática para node pools específicos

Pode impedir que o GKE faça a gestão dos nós em conjuntos de nós criados automaticamente existentes. Esta ação tem os seguintes efeitos:

• O escalador automático do cluster deixa de criar ou eliminar nós nesse node pool. Se quiser que o GKE ajuste automaticamente a escala dos nós, pode ativar separadamente o redimensionador automático de clusters para esse conjunto de nós.
• O GKE não elimina o node pool quando o número de nós é zero.
• O GKE continua a colocar pods pendentes em nós existentes nesse conjunto de nós que tenham disponibilidade. Se o aprovisionamento automático de nós ainda estiver ativado para o cluster, o GKE também pode criar novos conjuntos de nós para os pods pendentes, conforme necessário.

Para desativar a criação automática para um pool de nós específico, execute o seguinte comando:

gcloud container node-pools update NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-autoprovisioning

Desative a administração de contas automática de nós para o cluster

Pode desativar a criação automática de conjuntos de nós para todo o cluster desativando a definição de cluster de aprovisionamento automático de nós. Esta ação tem os seguintes efeitos:

• O redimensionador automático do cluster deixa de criar e eliminar nós em node pools criados automaticamente existentes. Os conjuntos de nós criados manualmente que usam o escalador automático do cluster não são afetados.
• O GKE não cria automaticamente novos conjuntos de nós para cargas de trabalho pendentes. Monitorize o cluster para evitar Pods bloqueados.

• Se o cluster cumprir os seguintes requisitos, o GKE continua a criar novos conjuntos de nós para ComputeClasses que ativam a criação automática:

  • Usa a versão 1.33.3-gke.1136000 ou posterior do GKE.
  • Está inscrito no canal de lançamento rápido.

  Se o cluster não cumprir estes requisitos, o GKE não cria novos node pools para ComputeClasses que ativem a criação automática.

Se reativar a definição de aprovisionamento automático de nós ao nível do cluster mais tarde, o GKE não reativa a criação automática de node pools nos node pools existentes. Tem de marcar os node pools individuais como criados automaticamente.

Para desativar a definição de administração de contas automática de nós ao nível do cluster, selecione uma das seguintes opções:

Consola

1. Na Google Cloud consola, aceda à página Clusters do Kubernetes:

   Aceda aos clusters do Kubernetes

2. Clique no nome do cluster a modificar. É apresentada a página Detalhes do cluster.

3. Clique no separador Detalhes.

4. Na secção Automatização, na linha Aprovisionamento automático de nós, clique em Editar. É apresentado o painel Editar administração de contas automática do nó.

5. Desmarque a caixa de verificação Ativar aprovisionamento automático de nós.

6. Clique em Guardar alterações.

gcloud

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-autoprovisioning

O que se segue?

• Saiba mais sobre o escalamento automático de clusters.
• Saiba mais sobre os conjuntos de nós.
• Saiba mais acerca das estratégias de atualização de nós.