Executar cargas de trabalho no modo Autopilot em clusters Standard

Os administradores de cluster e os operadores de aplicativos podem aproveitar os benefícios do GKE Autopilot, como preços e configurações predefinidas, em clusters do modo Standard. Neste documento, mostramos como usar ComputeClasses para implantar uma carga de trabalho do Autopilot em um cluster Standard. Você já precisa conhecer os seguintes conceitos:

Sobre as ComputeClasses do Autopilot

O GKE fornece recursos personalizados do Kubernetes chamados ComputeClasses que podem ser implantados no seu 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 suas cargas de trabalho, o que indica ao GKE que todos os novos nós devem usar uma das configurações nessa lista.

Se uma carga de trabalho selecionar uma ComputeClass com 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 muitos dos recursos padrão do Autopilot e configurações de segurança. Para mais informações sobre as implicações de executar uma carga de trabalho do Autopilot nos clusters padrão, incluindo 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 oferece ComputeClasses integradas do Autopilot que podem ser usadas na 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 de se as cargas de trabalho precisam de hardware específico, da seguinte maneira:

  • Cargas de trabalho de uso geral: use uma das ComputeClasses integradas do Autopilot, 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 essa ComputeClass 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 aplicável depende de você usar uma ComputeClass do Autopilot integrada ou personalizada. 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 CLI do Google Cloud para essa tarefa, instale e inicialize a gcloud CLI. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da gcloud CLI não sejam compatíveis com a execução dos comandos neste documento.
  • Use um cluster do GKE Standard que execute a versão 1.33.1-gke.1107000 ou mais recente e esteja registrado no canal de lançamento rápido. Para criar um cluster, consulte Como criar um cluster regional.
  • Para evitar rejeições de carga de trabalho, saiba mais sobre os requisitos e as restrições de segurança do Autopilot. Para mais informações, consulte configurações predefinidas para nós do Autopilot.

Requisitos

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

    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 ativados por padrão.

  • Você precisa 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, desative a aplicação da política de rede.

Limitações

  • Somente o canal de lançamento rápido é compatível.
  • 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.
  • Não é possível usar a regra de prioridade podFamily nas suas próprias ComputeClasses. Essa regra está disponível apenas nas ComputeClasses integradas do Autopilot.
  • As ComputeClasses integradas do Autopilot não oferecem suporte à ativação dos Confidential GKE Nodes para todo o cluster. Se você ativar os nós confidenciais do GKE para o cluster, todos os novos pods que selecionarem as ComputeClasses integradas do Autopilot vão permanecer no estado Pending indefinidamente.
  • A aplicação da política de rede do Calico não é compatível. É preciso usar o GKE Dataplane V2 ou desativar a aplicação da política de rede.
  • O nome da sua 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 papéis personalizados ou outros papéis predefinidos.

Modificar clusters para atender aos requisitos do Autopilot

Use o console Google Cloud para verificar se o cluster Standard atende a todos os requisitos para executar cargas de trabalho no modo Autopilot. Você também pode usar o console Google Cloud para modificar o cluster e atender a esses requisitos.

Modificar um cluster atual

  1. No console do Google Cloud , acesse a página de 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 é aberta.

  3. Na seção Princípios básicos do cluster, encontre a seção Compatibilidade da classe de computação do Autopilot.

    Se esta 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 Desativada, clique em Editar a compatibilidade da classe de computação do Autopilot.

    Se esta seção não estiver disponível para edição, seu 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 depois da criação. Se não for possível interagir com a seção Compatibilidade da classe de computação do Autopilot, crie 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 console do Google Cloud , acesse a página Criar um cluster do Kubernetes.

    Acessar "Criar um cluster do Kubernetes"

  2. Na página Noções básicas sobre clusters, encontre a seção Maximize as opções de implantação com a classe de computação do Autopilot. Esta 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 definições do 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 vai aparecer.

Selecionar uma ComputeClass do Autopilot em uma carga de trabalho

Para executar uma carga de trabalho no modo Autopilot no cluster padrão, selecione uma ComputeClass que use o modo Autopilot. Para executar uma carga de trabalho no modo Autopilot, selecione uma das seguintes opções:

Console

  1. No console Google Cloud , 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 aparece.

  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 use o modo Autopilot. Essa ComputeClass pode ser qualquer uma das seguintes:

  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. É o mesmo rótulo que você usa para selecionar qualquer outra ComputeClass no GKE. As etapas a seguir mostram como criar um exemplo de implantação que seleciona uma ComputeClass e verifica se os pods são executados no modo Autopilot:

  1. Salve o seguinte exemplo de implantação 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 qualquer um dos seguintes:

  2. Implantar a carga de trabalho:

    kubectl apply -f autopilot-cc-deployment.yaml

Configurar uma ComputeClass personalizada do Autopilot

É possível configurar ComputeClasses personalizadas para usar o Autopilot. Use uma ComputeClass personalizada do Autopilot se as cargas de trabalho exigirem hardware específico para serem executadas de maneira ideal, como GPUs ou uma determinada série de máquinas do Compute Engine.

Se as cargas de trabalho não exigirem hardware específico, recomendamos que você use uma das ComputeClasses integradas do Autopilot. Para selecionar uma ComputeClass do Autopilot integrada, consulte a seção Selecionar uma ComputeClass do Autopilot em uma carga de trabalho acima.

Criar uma ComputeClass personalizada do Autopilot

  1. Salve o seguinte manifesto de exemplo ComputeClass como n4-class.yaml:

    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 que estão mais acima na lista de prioridades quando os recursos ficam disponíveis.

  2. Implante a ComputeClass:

    kubectl apply -f n4-class.yaml

  3. Verifique se a ComputeClass existe:

    kubectl get computeclasses

    O resultado será o seguinte:

    NAME                  AGE
n4-class              3s

Ativar o Autopilot para uma ComputeClass personalizada

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

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

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

  1. Em um editor de texto, atualize o arquivo de manifesto da ComputeClass 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 para o arquivo de manifesto atualizado.

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

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

Verificar se a carga de trabalho usa o Autopilot

Selecione uma das seguintes opções:

Console

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

    Acesse "Cargas de trabalho"

  2. Para sua 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 seus pods:

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

O resultado será o seguinte:

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

O GKE permite definir uma ComputeClass como padrão para um namespace. A classe padrão do namespace se aplica a todos os pods nesse namespace que não selecionam explicitamente uma ComputeClass diferente. Definir uma ComputeClass do Autopilot como padrão significa que você pode executar todos os pods em um namespace no modo Autopilot por padrão, a menos que a carga de trabalho selecione uma opção diferente.

Para mais informações, consulte Configurar uma ComputeClass padrão para um namespace.

A seguir