Executar cargas de trabalho do Autopilot em clusters do GKE 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. Nesta página, 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 suas 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 gcloud components update.
  • 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.

Limitações

  • Somente o canal de lançamento rápido é compatível.
  • Para atualizar os recursos ComputeClass atuais no cluster para usar o modo Autopilot, é necessário recriar a ComputeClass 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.

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

Selecionar uma ComputeClass do Autopilot em uma carga de trabalho

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 uma implantação de exemplo 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: "4Gi"

    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

  3. Para verificar se os pods usam o Autopilot, confira os nomes dos nós do host:

    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.

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 autopilot-n2-class.yaml:

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

    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 N2.
    • 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.
    • whenUnsatisfiable: o valor de DoNotScaleUp neste campo torna obrigatório para o GKE usar uma das regras no campo priorities para novos nós. Se nenhuma dessas regras de prioridade puder ser atendida, o GKE deixará o pod em um estado Pending até que os recursos estejam disponíveis. DoNotScaleUp é o valor padrão e recomendado para esse campo.

  2. Implante a ComputeClass:

    kubectl apply -f autopilot-n2-class.yaml

  3. Verifique se a ComputeClass existe:

    kubectl get computeclasses

    O resultado será assim:

    NAME                  AGE
autopilot-n2-class    3s

Ativar o Autopilot para uma ComputeClass personalizada

É possível ativar o Autopilot em ComputeClasses personalizadas que estão em um cluster Standard e têm o campo nodePoolAutoCreation.enabled na especificação definido como true. Ativar o Autopilot em uma classe de computação 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, 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 um novo nó, recrie todas 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

  • Para receber uma lista dos pods no cluster, use o comando kubectl get:

    kubectl get pods --output=custom-columns=Pod:.metadata.name,Node:.spec.nodeName

    O resultado será assim:

    Pod                         Node
helloweb-84c865764b-nzhxt   gk3-cluster-1-pool-3-68fc8dca-t54b
# lines omitted for clarity

    O prefixo gk3- no nome do nó indica que o pod está sendo executado no modo 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