Controle os atributos dos nós com dimensionamento automático com ComputeClasses personalizadas

Este documento mostra como controlar a infraestrutura de computação e o comportamento de escala automática dos clusters do Google Kubernetes Engine (GKE) com base nas necessidades específicas das suas cargas de trabalho através de ComputeClasses personalizadas.

Este documento destina-se a administradores de plataformas que querem definir declarativamente perfis de escalabilidade automática para nós e a operadores de clusters que querem executar as respetivas cargas de trabalho em ComputeClasses específicas.

Acerca das ComputeClasses personalizadas

As ComputeClasses personalizadas são recursos personalizados do Kubernetes que lhe permitem definir prioridades para o GKE seguir quando aprovisiona nós para executar as suas cargas de trabalho. Pode usar uma ComputeClass personalizada para fazer o seguinte:

  • Atribua ao GKE um conjunto de prioridades a seguir sequencialmente ao aprovisionar nós, cada um com parâmetros específicos, como uma série de máquinas do Compute Engine ou uma capacidade mínima de recursos
  • Defina os limites e os parâmetros do dimensionamento automático para remover nós subutilizados e consolidar as cargas de trabalho de forma eficiente na capacidade de computação existente
  • Indique ao GKE para substituir automaticamente as configurações de nós menos preferenciais por configurações de nós mais preferenciais para um desempenho ideal da carga de trabalho

Para compreender todas as opções de configuração e como interagem entre si e com o modo Autopilot do GKE e o modo Standard do GKE, consulte o artigo Acerca das ComputeClasses personalizadas.

Preços

O recurso personalizado ComputeClass é fornecido sem custos adicionais no GKE. Aplicam-se as seguintes considerações de preços:

Limitações

O nome da ComputeClass não pode começar por gke nem autopilot.

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.

Cenário de exemplo para ComputeClasses

Este documento apresenta um cenário de exemplo para o qual define uma ComputeClass personalizada. Na prática, deve considerar os requisitos das suas cargas de trabalho e organização específicas e definir ComputeClasses que cumpram esses requisitos. Para ver descrições completas de todas as opções de ComputeClasses e considerações especiais, consulte o artigo Acerca das ComputeClasses personalizadas.

Considere o seguinte cenário de exemplo:

  • O seu objetivo é otimizar os custos de execução das suas cargas de trabalho
  • As suas cargas de trabalho são tolerantes a falhas e não requerem encerramento controlado nem tempo de execução prolongado
  • As suas cargas de trabalho precisam de, pelo menos, 64 vCPUs para serem executadas de forma ideal
  • Tem um limite da série de máquinas N4 do Compute Engine

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

  • Dá prioridade aos nós Spot N4 que têm, pelo menos, 64 vCPUs
  • Permite que o GKE recorra a qualquer nó Spot N4, independentemente da capacidade de computação
  • Se não estiverem disponíveis nós N4 Spot, permite que o GKE use nós N4 a pedido
  • Indica ao GKE para mover as suas cargas de trabalho para nós Spot sempre que estiverem novamente disponíveis

Configure uma ComputeClass no modo Autopilot

No GKE Autopilot, define uma ComputeClass, implementa-a no cluster e pede essa ComputeClass nas suas cargas de trabalho. O GKE executa todos os passos de configuração de nós, como aplicar etiquetas e restrições, por si.

Guarde 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

Configure uma ComputeClass no modo padrão

Nos clusters do modo padrão do GKE, pode ter de fazer a configuração manual para garantir que os pods ComputeClass são agendados conforme esperado. A configuração manual depende de os seus conjuntos de nós serem criados automaticamente, da seguinte forma:

Para permitir que o GKE crie automaticamente pools de nós para a sua ComputeClass, siga estes passos:

  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 aprovisionamento automático de nós ao nível do cluster.

  2. Guarde 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 implementa pods que pedem esta ComputeClass de exemplo e é necessário criar novos nós, o GKE dá prioridade à criação de nós pela ordem dos itens no campo priorities. Se necessário, o GKE cria novos conjuntos de nós que cumprem os requisitos de hardware da ComputeClass.

Também pode especificar um tipo de máquina personalizado preciso nas suas prioridades. A utilização de tipos de máquinas personalizados requer a versão 1.33.2-gke.1111000 ou posterior do GKE. O exemplo seguinte configura uma ComputeClass que dá prioridade às VMs do Spot para o n4-custom-8-20480 tipo de máquina personalizado e recorre a VMs a pedido 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

Use ComputeClasses com node pools criados manualmente

Esta secção mostra como definir uma ComputeClass num cluster que só usa pools de nós criados manualmente.

  1. Guarde 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 node pool com escalonamento automático que use VMs do Spot e associe-o à 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 o seguinte:

    • LOCATION: a localização do seu cluster.
    • CLUSTER_NAME: o nome do cluster existente.

  3. Crie um novo node pool com escala automática com VMs a pedido 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 implementa pods que pedem esta ComputeClass e é necessário criar novos nós, o GKE dá prioridade à criação de nós no conjunto de nós cost-optimized-pool. Se não for possível criar novos nós, o GKE cria nós no conjunto de nós on-demand-pool.

Para mais detalhes sobre como os conjuntos de nós criados manualmente interagem com as ComputeClasses personalizadas, consulte o artigo Configure conjuntos de nós criados manualmente para utilização da ComputeClass.

Personalize os limites de dimensionamento automático para a consolidação de nós

Por predefinição, o GKE remove os nós subutilizados e reagenda as suas cargas de trabalho para outros nós disponíveis. Pode personalizar ainda mais os limites e o tempo após o qual um nó se torna candidato à remoção através do campo autoscalingPolicy na definição ComputeClass, como no seguinte exemplo:

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 um candidato à remoção se for subutilizado em 70% da respetiva capacidade de CPU e memória disponíveis durante mais de cinco minutos. Para ver uma lista dos parâmetros disponíveis, consulte o artigo Defina parâmetros de dimensionamento automático para a consolidação de nós.

Implemente uma ComputeClass num cluster

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

kubectl apply -f compute-class.yaml

Esta ComputeClass está pronta a usar no cluster. Pode pedir a ComputeClass nas especificações do pod ou, opcionalmente, defini-la como a ComputeClass predefinida num espaço de nomes específico.

Peça uma ComputeClass num volume de trabalho

Para pedir uma ComputeClass numa carga de trabalho, adicione um seletor de nós para essa ComputeClass no seu manifesto, como nos passos seguintes:

  1. Guarde 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. Implemente a carga de trabalho:

    kubectl apply -f cc-workload.yaml

Quando implementa esta carga de trabalho, o GKE adiciona automaticamente uma tolerância aos pods que corresponde à contaminação do nó para a ComputeClass pedida. Esta tolerância garante que apenas os pods que pedem a ComputeClass são executados em nós ComputeClass.

Atualize uma ComputeClass implementada

Para atualizar uma ComputeClass implementada, modifique o manifesto YAML da ComputeClass. Em seguida, implemente o manifesto modificado executando o seguinte comando:

kubectl apply -f PATH_TO_FILE

Substitua PATH_TO_FILE pelo caminho para o manifesto modificado. Certifique-se de que o valor no campo name permanece inalterado.

Quando implementa a ComputeClass atualizada, o GKE usa a configuração atualizada para criar novos nós. O GKE não modifica nenhum nó existente com a sua configuração atualizada.

Ao longo do tempo, o GKE pode mover os pods existentes para nós que usam a sua configuração atualizada se a ComputeClass usar a migração ativa e se os pods existentes forem elegíveis para migração.

O que se segue?