Controlar atributos de nós com escalonamento automático usando ComputeClasses personalizadas

Neste documento, mostramos como controlar a infraestrutura de computação e o comportamento de dimensionamento automático dos clusters do Google Kubernetes Engine (GKE) com base nas necessidades específicas das cargas de trabalho usando ComputeClasses personalizadas.

Este documento é destinado a administradores de plataformas que querem definir de forma declarativa perfis de escalonamento automático para nós e para operadores de cluster que querem executar cargas de trabalho em ComputeClasses específicas.

Sobre as ComputeClasses personalizadas

As ComputeClasses personalizadas são os Recursos personalizados do Kubernetes que permitem definir prioridades para o GKE seguir ao provisionar nós para executar as cargas de trabalho. É possível usar uma ComputeClass personalizada para fazer o seguinte:

  • Dê ao GKE um conjunto de prioridades para seguir sequencialmente ao provisionar nós, cada um com parâmetros específicos, como série de máquinas do Compute Engine ou capacidade mínima de recursos
  • Definir limites e parâmetros de escalonamento automático para remover nós subutilizados e consolidar cargas de trabalho de maneira eficiente na capacidade de computação atual
  • Instrua o GKE a substituir automaticamente as configurações de nó menos preferenciais por configurações de nó mais preferenciais para um desempenho de carga de trabalho otimizado

Para entender todas as opções de configuração e como elas interagem entre si e com o modo Autopilot do GKE e o modo GKE Standard, consulte Sobre as ComputeClasses personalizadas.

Preços

O recurso personalizado ComputeClass é fornecido sem custo financeiro extra no GKE. As seguintes considerações de preço se aplicam:

Limitações

O nome da sua ComputeClass não pode começar com gke ou autopilot.

Antes de começar

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

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

Exemplo de cenário para ComputeClasses

Neste documento, apresentamos um exemplo de cenário em que você define uma ComputeClass personalizada. Na prática, considere os requisitos das suas cargas de trabalho e organização específicas e defina ComputeClasses que atendam a esses requisitos. Para descrições completas de todas as opções de ComputeClasses, e para considerações especiais, consulte Sobre as ComputeClasses personalizadas.

Pense neste cenário de exemplo:

  • Seu objetivo é otimizar os custos de execução das cargas de trabalho
  • Suas cargas de trabalho são tolerantes a falhas e não exigem desligamento suave ou tempo de execução estendido
  • Suas cargas de trabalho precisam de pelo menos 64 vCPUs para serem executadas de maneira ideal
  • Você só pode usar a série de máquinas N4 do Compute Engine

Com base no cenário de exemplo, você decide que quer uma ComputeClass que faça o seguinte:

  • Prioriza os nós do N4 Spot com pelo menos 64 vCPU
  • Permite que o GKE use qualquer nó do Spot N4, independentemente da capacidade de computação
  • Se nenhum nó do Spot N4 estiver disponível, o GKE poderá usar nós do N4 sob demanda.
  • Instrui o GKE a mover as cargas de trabalho para nós do Spot sempre que fiquem disponíveis de novo

Configurar uma ComputeClass no modo Autopilot

No GKE Autopilot, você define uma ComputeClass, faz a implantação no cluster e solicita essa ComputeClass nas cargas de trabalho. O GKE executa todas as etapas de configuração do nó, como a aplicação de rótulos e taints, para você.

Salve o seguinte manifesto como compute-class.yaml:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

Configurar uma ComputeClass no modo padrão

Nos clusters do modo GKE Standard, talvez seja necessário realizar configuração manual para garantir que os pods do ComputeClass sejam programados conforme esperado. A configuração manual depende de se os pools de nós são criados automaticamente, da seguinte maneira:

Para permitir que o GKE crie automaticamente pools de nós para sua ComputeClass, siga estas etapas:

  1. Para clusters do modo Standard que executam uma versão anterior a 1.33.3-gke.1136000 e não estão inscritos no canal de lançamento Rápido, ative o provisionamento automático de nós no nível do cluster.

  2. Salve o seguinte manifesto de exemplo como compute-class.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

    Quando você implanta pods que solicitam essa ComputeClass de exemplo e novos nós precisam ser criados, o GKE prioriza a criação de nós na ordem dos itens no campo priorities. Se necessário, o GKE cria pools de nós que atendem aos requisitos de hardware da ComputeClass.

Também é possível especificar um tipo de máquina personalizado preciso nas suas prioridades. O uso de tipos de máquina personalizados requer o GKE versão 1.33.2-gke.1111000 ou mais recente. O exemplo a seguir configura uma ComputeClass que prioriza VMs Spot para o tipo de máquina personalizado n4-custom-8-20480 e volta para VMs sob demanda do mesmo tipo se a capacidade do Spot não estiver disponível:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: custom-machine-type
spec:
  priorities:
  - machineType: n4-custom-8-20480
    spot: true
  - machineType: n4-custom-8-20480
    spot: false
  nodePoolAutoCreation:
    enabled: true

Usar ComputeClasses com pools de nós criados manualmente

Esta seção mostra como definir uma ComputeClass em um cluster que usa apenas pools de nós criados manualmente.

  1. Salve o seguinte manifesto como compute-class.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true

  2. Crie um novo pool de nós com escalonamento automático que usa VMs Spot e o associe à ComputeClass:

    gcloud container node-pools create cost-optimized-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n4-standard-64 \
    --spot \
    --enable-autoscaling \
    --max-nodes=9 \
    --node-labels="cloud.google.com/compute-class=cost-optimized" \
    --node-taints="cloud.google.com/compute-class=cost-optimized:NoSchedule"

    Substitua:

    • LOCATION: o local do cluster.
    • CLUSTER_NAME: o nome do cluster atual.

  3. Crie um novo pool de nós com escalonamento automático e VMs sob demanda e associe-o à ComputeClass:

    gcloud container node-pools create on-demand-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n4-standard-64 \
    --enable-autoscaling \
    --max-nodes=9 \
    --num-nodes=0 \
    --node-labels="cloud.google.com/compute-class=cost-optimized" \
    --node-taints="cloud.google.com/compute-class=cost-optimized:NoSchedule"

Quando você implanta pods que solicitam essa ComputeClass e novos nós precisam ser criados, o GKE prioriza a criação de nós no pool de nós cost-optimized-pool. Se não for possível criar novos nós, o GKE vai criar nós no pool de nós on-demand-pool.

Para mais detalhes sobre como os pools de nós criados manualmente interagem com classes de computação personalizadas, consulte Configurar pools de nós criados manualmente para uso de classes de computação.

Personalizar limites de escalonamento automático para consolidação de nós

Por padrão, o GKE remove nós subutilizados e reprograma as cargas de trabalho em outros nós disponíveis. É possível personalizar ainda mais os limites e o tempo após o qual um nó se torna um candidato à remoção usando o campo autoscalingPolicy na definição de ComputeClass, como no exemplo abaixo:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true
  autoscalingPolicy:
    consolidationDelayMinutes : 5
    consolidationThreshold    : 70

Este exemplo faz com que um nó se torne candidato a remoção se for subutilizado por 70% da CPU e da capacidade de memória disponíveis por mais de cinco minutos. Para conferir uma lista de parâmetros disponíveis, consulte Definir parâmetros de escalonamento automático para consolidação de nós.

Implantar uma ComputeClass em um cluster

Depois de definir uma ComputeClass, implante-a no cluster:

kubectl apply -f compute-class.yaml

Essa classe de computação está pronta para uso no cluster. É possível solicitar a ComputeClass nas especificações do pod ou, opcionalmente, defini-la como a ComputeClass padrão em um namespace específico.

Solicitar uma ComputeClass em uma carga de trabalho

Para solicitar uma ComputeClass em uma carga de trabalho, adicione um seletor de nós para essa ComputeClass no manifesto, como nas etapas a seguir:

  1. Salve o seguinte manifesto como cc-workload.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: custom-workload
spec:
  replicas: 2
  selector:
    matchLabels:
      app: custom-workload
  template:
    metadata:
      labels:
        app: custom-workload
    spec:
      nodeSelector:
        cloud.google.com/compute-class: cost-optimized
      containers:
      - name: test
        image: gcr.io/google_containers/pause
        resources:
          requests:
            cpu: 1.5
            memory: "4Gi"

  2. Implantar a carga de trabalho:

    kubectl apply -f cc-workload.yaml

Quando você implanta essa carga de trabalho, o GKE adiciona automaticamente uma tolerância aos pods que corresponde ao taint do nó para a ComputeClass solicitada. Essa tolerância garante que apenas pods que solicitam a ComputeClass sejam executados em nós da ComputeClass.

Atualizar uma ComputeClass implantada

Para atualizar uma ComputeClass implantada, modifique o manifesto YAML dela. Em seguida, execute este comando para implantar o manifesto modificado:

kubectl apply -f PATH_TO_FILE

Substitua PATH_TO_FILE pelo caminho para o manifesto modificado. Verifique se o valor no campo name permanece inalterado.

Quando você implanta a ComputeClass atualizada, o GKE usa a configuração atualizada para criar novos nós. O GKE não modifica nenhum nó atual com a configuração atualizada.

Com o tempo, o GKE poderá mover os pods atuais para nós que usam sua configuração atualizada se a ComputeClass usar a migração ativa e se os pods atuais estiverem qualificados para migrar.

A seguir