Executar cargas de trabalho no modo Autopilot em clusters Standard

Os administradores de clusters e operadores de aplicativos podem aproveitar os benefícios do Autopilot do Google Kubernetes Engine (GKE), como preços e configurações predefinidas, em clusters do modo Standard. Este documento mostra como usar ComputeClasses para implantar uma carga de trabalho do Autopilot em um cluster Standard. Você já deve estar familiarizado com estes conceitos:

Sobre as ComputeClasses do Autopilot

O GKE fornece recursos personalizados do Kubernetes chamados ComputeClasses que podem ser implantados no cluster como qualquer outro recurso do Kubernetes. Uma ComputeClass define uma lista de configurações de nós, como tipos de máquinas ou VMs Spot. É possível selecionar ComputeClasses nas cargas de trabalho, o que indica ao GKE que todos os novos nós precisam usar uma das configurações dessa lista.

Se uma carga de trabalho selecionar uma ComputeClass que tenha o campo autopilot ativado, o GKE vai executar os pods no modo Autopilot. Os nós criados pelo GKE são gerenciados pelo Google e incluem muitas das configurações de recursos e segurança padrão do Autopilot. Para mais informações sobre as implicações da execução de uma carga de trabalho do Autopilot nos clusters Standard, incluindo as diferenças que você pode notar ao implantar essas cargas de trabalho, consulte Sobre cargas de trabalho do modo Autopilot no GKE Standard.

Tipos de ComputeClasses do Autopilot

O GKE fornece ComputeClasses do Autopilot integradas que podem ser usadas para a maioria das cargas de trabalho de uso geral. Também é possível configurar uma ComputeClass personalizada nova ou atual para usar o modo Autopilot. O tipo de ComputeClass do Autopilot que você usa depende se as cargas de trabalho precisam de hardware específico, da seguinte maneira:

  • Cargas de trabalho de uso geral: use uma das ComputeClasses do Autopilot integradas, que colocam pods na plataforma de computação otimizada para contêineres.
  • Cargas de trabalho que exigem hardware específico: ative o modo Autopilot para qualquer ComputeClass personalizada, implante essa ComputeClass no cluster e selecione-a nas cargas de trabalho.

Para mais informações sobre essas opções, quando usá-las e os preços de cada uma, consulte Seleção de hardware em ComputeClasses do Autopilot.

Preços

Os preços do GKE Autopilot se aplicam às cargas de trabalho e aos nós que usam uma ComputeClass do Autopilot. O modelo de preços que se aplica depende da regra de prioridade da ComputeClass que o GKE usa para criar nós para as cargas de trabalho. Para mais informações, consulte Preços em "Sobre cargas de trabalho do modo Autopilot no GKE Standard".

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 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.

Requisitos

  • O cluster precisa executar uma das seguintes versões do GKE:

    • Para usar o Autopilot em ComputeClasses, o cluster precisa executar a versão 1.34.1-gke.1829001 ou mais recente.
    • Para usar regras de prioridade podFamily em ComputeClasses do Autopilot personalizadas, o cluster precisa executar a versão 1.35.2-gke.1485000 ou mais recente.

  • Pelo menos um pool de nós no cluster não pode ter cor.

    Esse pool de nós é necessário para executar pods do sistema GKE Standard que não podem ser executados em nós do Autopilot em clusters Standard devido aos taints que o GKE adiciona a esses nós.

  • Os nós protegidos do GKE são obrigatórios e estão ativados por padrão.

  • É preciso usar um cluster nativo de VPC.

  • Se você usar NetworkPolicies do Kubernetes, o cluster precisará usar o GKE Dataplane V2. Por padrão, todos os novos clusters usam o GKE Dataplane V2.

    Se o cluster não usar o GKE Dataplane V2, será necessário desativar a aplicação da política de rede.

Limitações

  • A família de pods general-purpose-arm e a classe de computação autopilot-arm só estão disponíveis em clusters do Autopilot. Os clusters Standard com nós do Autopilot serão compatíveis em uma versão posterior.
  • Para atualizar as ComputeClasses atuais no cluster para usar o modo Autopilot, é necessário recriar essas ComputeClasses com uma especificação atualizada. Para mais informações, consulte Ativar o Autopilot para uma ComputeClass personalizada.
  • As ComputeClasses do Autopilot integradas não oferecem suporte à ativação de nós protegidos do GKE para todo o cluster. Se você ativar os nós protegidos do GKE para o cluster, todos os novos pods que selecionarem as ComputeClasses do Autopilot integradas vão permanecer no estado Pending indefinidamente.
  • A aplicação da política de rede do Calico não é compatível. É necessário usar o GKE Dataplane V2 ou desativar a aplicação da política de rede.
  • O nome da ComputeClass não pode começar com gke ou autopilot, que são prefixos reservados.

Papéis e permissões necessárias

Para receber as permissões necessárias para implantar ComputeClasses, peça ao administrador para conceder a você o papel do IAM de desenvolvedor do Kubernetes Engine (roles/container.developer) no cluster ou projeto . Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando personalizados papéis ou outros predefinidos papéis.

Modificar clusters para atender aos requisitos do Autopilot

É possível usar o Google Cloud console para verificar se o cluster Standard atende a todos os requisitos para executar cargas de trabalho no modo Autopilot. Também é possível usar o Google Cloud console para modificar o cluster para atender a esses requisitos.

Modificar um cluster atual

  1. No Google Cloud console do, acesse a página Clusters do Kubernetes.

    Acessar os clusters do Kubernetes

  2. Na linha do cluster que você quer modificar, clique em Mais ações > Editar. A página Detalhes do cluster será aberta.

  3. Na seção Noções básicas sobre clusters, encontre a seção Compatibilidade da classe de computação do Autopilot.

    Se essa seção mostrar Ativado, o cluster já será compatível com o Autopilot. Pule para a seção Selecionar uma ComputeClass do Autopilot em uma carga de trabalho.

  4. Se a seção Compatibilidade da classe de computação do Autopilot mostrar Desativado, clique em Editar a compatibilidade da classe de computação do Autopilot.

    Se essa seção não estiver disponível para edição, o cluster usará uma configuração permanente incompatível com o modo Autopilot. Por exemplo, não é possível modificar clusters para serem nativos de VPC após a criação do cluster. Se não for possível interagir com a seção Compatibilidade da classe de computação do Autopilot, será necessário criar um novo cluster.

  5. No painel Compatibilidade da classe de computação do Autopilot que é aberto, revise as configurações do cluster que precisam ser alteradas para atender aos requisitos do modo Autopilot.

  6. Clique em Ativar a classe de computação do Autopilot. O GKE modifica o cluster conforme necessário.

Modificar um novo cluster

  1. No Google Cloud console, acesse a página **Criar um cluster do Kubernetes**.

    Acessar a página Criar um cluster do Kubernetes

  2. Na página Noções básicas sobre clusters, encontre a seção Maximizar as opções de implantação com a classe de computação do Autopilot. Essa seção mostra as configurações do cluster que precisam ser alteradas para atender aos requisitos do modo Autopilot.

  3. Clique em Ativar a classe de computação do Autopilot. O GKE modifica o cluster conforme necessário.

  4. Configure outras configurações de cluster com base nos seus requisitos. Se você modificar uma configuração que torna o cluster incompatível com o Autopilot, uma mensagem de aviso será exibida.

Selecionar uma ComputeClass do Autopilot em uma carga de trabalho

É possível executar uma carga de trabalho no modo Autopilot no cluster Standard selecionando uma ComputeClass que usa o modo Autopilot. Para executar uma carga de trabalho no modo Autopilot, selecione uma das seguintes opções:

Console

  1. No Google Cloud console, acesse a página Cargas de trabalho do GKE.

    Acesse "Cargas de trabalho"

  2. Clique em Implantar ou Criar job. A página de criação de carga de trabalho para uma implantação ou um job será exibida.

  3. Na seção Nós, selecione Classe de computação do Autopilot.

  4. Na seção Selecionar classe de computação, na lista suspensa Classe de computação, selecione uma ComputeClass que usa o modo Autopilot. Essa ComputeClass pode ser qualquer uma das seguintes:

    • Uma das seguintes ComputeClasses do Autopilot integradas, que colocam cargas de trabalho de uso geral na plataforma de computação otimizada para contêineres do Autopilot:

      • autopilot
      • autopilot-spot

    • Uma ComputeClass criada por você, como a n4-class ComputeClass descrita na seção Configurar uma ComputeClass do Autopilot personalizada.

  5. Configure e crie a carga de trabalho.

CLI kubectl

Para selecionar uma ComputeClass do Autopilot em uma carga de trabalho, use um seletor de nós para o rótulo cloud.google.com/compute-class. Esse é o mesmo rótulo usado para selecionar qualquer outra ComputeClass no GKE. As etapas a seguir mostram como criar uma implantação de exemplo que seleciona uma ComputeClass e verifica se os pods são executados no modo Autopilot:

  1. Salve a seguinte implantação de exemplo como autopilot-cc-deployment.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"

    Substitua COMPUTE_CLASS pelo nome da classe de computação a ser usada. Esse valor pode ser um dos seguintes:

    • Uma das seguintes ComputeClasses do Autopilot integradas, que colocam cargas de trabalho de uso geral na plataforma de computação otimizada para contêineres do Autopilot:

      • autopilot
      • autopilot-spot

    • Uma ComputeClass criada por você, como a n4-class ComputeClass descrita na seção Configurar uma ComputeClass do Autopilot personalizada.

  2. Implantar a carga de trabalho:

    kubectl apply -f autopilot-cc-deployment.yaml

Configurar uma ComputeClass do Autopilot personalizada

É possível configurar ComputeClasses personalizadas para usar o Autopilot. Use uma ComputeClass do Autopilot personalizada em situações como as seguintes:

  • As cargas de trabalho exigem hardware específico para serem executadas de maneira ideal, como GPUs ou uma determinada série de máquinas do Compute Engine.
  • Você quer ajustar as configurações de nós, como zonas ou taints, ao usar a plataforma de computação otimizada para contêineres do Autopilot.

Se as cargas de trabalho não tiverem esses requisitos, recomendamos que você use uma das ComputeClasses do Autopilot integradas. Para selecionar uma ComputeClass do Autopilot integrada, consulte a seção anterior Selecionar uma ComputeClass do Autopilot em uma carga de trabalho.

Criar uma nova ComputeClass do Autopilot personalizada

  1. Salve um dos seguintes manifestos de ComputeClass de exemplo:

    • Selecionar máquinas específicas:

      apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: n4-class
spec:
  autopilot:
    enabled: true
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 16
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true

      Esse manifesto inclui os seguintes campos:

      • autopilot: ativa o modo Autopilot para a ComputeClass. Se você especificar esse campo em uma ComputeClass implantada em um cluster do Autopilot, o GKE vai ignorar o campo.
      • priorities: define uma matriz de três configurações diferentes da família de máquinas N4.
      • activeMigration: permite que o GKE migre pods para configurações mais altas na lista de prioridades quando os recursos ficam disponíveis.

    • Usar a plataforma de computação otimizada para contêineres com modificações:

      apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: general-purpose-class
spec:
  autopilot:
    enabled: true
  priorities:
  - podFamily: general-purpose
  priorityDefaults:
    location:
      zones: ['us-central1-a','us-central1-b','us-central1-f']

      Esse manifesto inclui os seguintes campos:

      • autopilot: ativa o modo Autopilot para a ComputeClass. Se você especificar esse campo em uma ComputeClass implantada em um cluster do Autopilot, o GKE vai ignorar o campo.
      • priorities.podFamily: usa a regra de prioridade podFamily para executar pods na plataforma de computação otimizada para contêineres do Autopilot.
      • priorityDefaults.location: define as zonas em que o GKE precisa criar nós para pods que usam a ComputeClass.

  2. Implante a ComputeClass:

    kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST

    Substitua PATH_TO_COMPUTECLASS_MANIFEST pelo caminho do manifesto da ComputeClass da etapa anterior.

  3. Verifique se a ComputeClass existe:

    kubectl get computeclasses

    O resultado será assim:

    NAME                  AGE
n4-class              3s

Ativar o Autopilot para uma ComputeClass personalizada

É possível ativar o Autopilot em ComputeClasses personalizadas atuais que estão em um cluster Standard. A ativação do Autopilot em uma ComputeClass que está em um cluster do Autopilot não tem efeito, porque todo o cluster usa o modo Autopilot.

Depois de ativar o Autopilot para uma ComputeClass atual, o GKE usa o Autopilot para executar novos pods que selecionam a ComputeClass. Se você tiver pods atuais em nós Standard que selecionam a ComputeClass do Autopilot, esses pods vão usar o Autopilot somente quando forem recriados.

Para atualizar uma ComputeClass personalizada atual para usar o modo Autopilot, siga estas etapas:

  1. Em um editor de texto, atualize o arquivo de manifesto da ComputeClass atual para adicionar o campo spec.autopilot:

    spec:
  autopilot:
    enabled: true

  2. Substitua o recurso ComputeClass atual na API Kubernetes pela especificação atualizada:

    kubectl replace --force -f PATH_TO_UPDATED_MANIFEST

    Substitua PATH_TO_UPDATED_MANIFEST pelo caminho do arquivo de manifesto atualizado.

  3. Para acionar a criação de novos nós, recrie todas as cargas de trabalho que usam a classe de computação.

Depois de aplicar o manifesto atualizado, todos os novos nós que o GKE criar para essa ComputeClass vão usar o Autopilot. O GKE não modifica nenhum nó atual criado antes da atualização.

Verificar se a carga de trabalho usa o Autopilot

Selecione uma das seguintes opções:

Console

  1. No Google Cloud console, acesse a página Cargas de trabalho do GKE.

    Acesse "Cargas de trabalho"

  2. Para a carga de trabalho, verifique o valor na coluna Tipo de nó. Se a carga de trabalho usar o modo Autopilot, esse valor será Gerenciado pelo Autopilot.

CLI kubectl

Verifique os nomes dos nós que executam os pods:

kubectl get pods -l=app=hello -o wide

O resultado será assim:

NAME                       READY   STATUS    RESTARTS   AGE     IP             NODE                                         NOMINATED NODE   READINESS GATES
helloweb-79b9f6f75-5wwc9   1/1     Running   0          152m    10.102.1.135   gk3-cluster-1-nap-10abc8ya1-f66c6cef-wg5g   <none>           <none>
helloweb-79b9f6f75-9skb9   1/1     Running   0          4d3h    10.102.0.140   gk3-cluster-1-nap-10abc8ya1-632bac02-hjl6   <none>           <none>
helloweb-79b9f6f75-h7bdv   1/1     Running   0          152m    10.102.1.137   gk3-cluster-1-nap-10abc8ya1-f66c6cef-wg5g   <none>           <none>

Nessa saída, o prefixo gk3- na coluna Nó indica que o nó é gerenciado pelo Autopilot.

Aplicar uma ComputeClass do Autopilot por padrão

É possível definir uma ComputeClass integrada ou personalizada como a ComputeClass padrão para um namespace ou para um cluster inteiro. A ComputeClass padrão se aplica a qualquer pod que não selecione explicitamente uma ComputeClass diferente. Se você definir uma ComputeClass do Autopilot como padrão, poderá garantir que todos os pods sejam executados no modo Autopilot, a menos que uma carga de trabalho selecione uma opção diferente.

Se a ComputeClass definida como padrão usar regras de prioridade podFamily, os pods que não selecionarem uma ComputeClass diferente poderão ser executados como pods do Autopilot de uso geral. Esse método permite usar o modelo de faturamento baseado em pod por padrão no cluster ou namespace e é útil quando muitas cargas de trabalho não têm requisitos de hardware especiais.

Para mais informações, consulte Aplicar ComputeClasses a pods por padrão.

A seguir