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

Esta página mostra 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 suas cargas de trabalho através de ComputeClasses personalizadas. Já deve estar familiarizado com o conceito de ComputeClasses personalizadas. Para obter detalhes, consulte o artigo Acerca das ComputeClasses personalizadas.

Esta página 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:

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 gcloud components update para obter a versão mais recente.

Cenário de exemplo para ComputeClasses

Esta página apresenta um cenário de exemplo para o qual define uma classe de computação 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
  • Está limitado à série de máquinas do Compute Engine N4

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, define uma classe de computação, após o que pode ter de fazer uma configuração manual para garantir que os pods da classe de computação são agendados conforme esperado. A configuração manual depende de os conjuntos de nós serem aprovisionados automaticamente, da seguinte forma:

  • Node pools geridos pela administração de contas automática de nós: não é necessária configuração manual. A administração de contas automática de nós executa automaticamente os passos de configuração da ComputeClass. Para mais detalhes, consulte o artigo Aprovisionamento automático de nós e ComputeClasses.
  • Node pools criados manualmente: é necessária uma configuração manual. Tem de adicionar etiquetas de nós e taints de nós aos conjuntos de nós criados manualmente para associar os nós a uma ComputeClass específica. Para obter detalhes, consulte o artigo Configure manualmente pools de nós para utilização da ComputeClass.

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.

Use ComputeClasses com node pools aprovisionados automaticamente

Esta secção mostra como definir uma ComputeClass num cluster que usa o aprovisionamento automático de nós.

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

Quando implementa pods que pedem esta ComputeClass 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 pools 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 tipo de máquina personalizado n4-custom-8-20480 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

Para mais detalhes sobre como o aprovisionamento automático de nós funciona com classes de computação personalizadas, consulte o artigo Aprovisionamento automático de nós e ComputeClasses.

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ível 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 classe de computação 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 classe de computação no seu manifesto.

  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 à restrição do nó para a ComputeClass pedida. Esta tolerância garante que apenas os pods que pedem a classe de computação 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?