Controlar atributos de nó com escalonamento automático usando classes de computação personalizadas

Nesta página, 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 classes de computação personalizadas. Você já deve estar familiarizado com o conceito de classes de computação personalizadas. Para mais detalhes, consulte Sobre as classes de computação personalizadas.

Esta página é destinada 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 classes de computação específicas.

Sobre as classes de computação personalizadas

As classes de computação 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 classe de computação 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 com cada uma e com o modo Autopilot do GKE e com o modo GKE Standard, consulte Sobre as classes de computação personalizadas.

Preços

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

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 Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando gcloud components update.

Exemplo de cenário para classes de computação

Nesta página, apresentamos um exemplo de cenário em que você define uma classe de computação personalizada. Na prática, considere os requisitos das suas cargas de trabalho e organização específicas e defina classes de computação que atendam a esses requisitos. Para descrições completas de todas as opções de classes de computação, e para considerações especiais, consulte Sobre as classes de computação 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 N2 do Compute Engine

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

  • Prioriza os nós do N2 Spot com pelo menos 64 vCPU
  • Permite que o GKE use qualquer nó do Spot N2, independentemente da capacidade de computação
  • Se nenhum nó do Spot N2 estiver disponível, o GKE poderá usar nós do N2 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 classe de computação no modo Autopilot

No GKE Autopilot, você define uma classe de computação, faz a implantação no cluster e solicita essa classe de computação 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: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

Configurar uma classe de computação no modo padrão

Nos clusters do modo GKE Standard, você define uma classe de computação, após talvez seja necessário executar a configuração manual para garantir a programação dos pods de classe de computação conforme esperado. A configuração manual depende se os pools de nós são provisionados automaticamente, da seguinte maneira:

Usar classes de computação com pools de nós criados manualmente

Esta seção mostra como definir uma classe de computação 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: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true

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

    gcloud container node-pools create cost-optimized-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n2-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 à classe de computação:

    gcloud container node-pools create on-demand-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n2-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 classe de computação 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.

Usar classes de computação com pools de nós provisionados automaticamente

Esta seção mostra como definir uma classe de computação em um cluster que usa o provisionamento automático de nós.

Salve o seguinte manifesto como compute-class.yaml:

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

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

Para mais detalhes sobre como o provisionamento automático de nós funciona com classes de computação personalizadas, consulte Provisionamento automático de nós e 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 da classe de computação, como no exemplo abaixo:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    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 classe de computação em um cluster

Depois de definir uma classe de computação, 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 classe de computação nas especificações do pod ou, opcionalmente, defini-la como a classe de computação padrão em um namespace específico.

Definir uma classe de computação padrão para um namespace

Quando você define uma classe de computação padrão para um namespace, o GKE usa essa classe de computação para criar nós para todos os pods implantados. Se um pod solicitar explicitamente uma classe de computação diferente, a solicitação no nível do pod substitui o padrão do namespace.

Para definir uma classe de computação como padrão para um namespace específico, faça o seguinte:

  1. Para criar um namespace:

    kubectl create namespace cost-optimized-ns

  2. Rotule o namespace com a classe de computação:

    kubectl label namespaces cost-optimized-ns \
    cloud.google.com/default-compute-class=cost-optimized

Solicitar uma classe de computação em uma carga de trabalho

Para solicitar uma classe de computação em uma carga de trabalho, adicione um seletor de nós para essa classe de computação no manifesto.

  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 classe de computação solicitada. Essa tolerância garante que apenas pods que solicitam a classe de computação sejam executados em nós da classe de computação.

A seguir