Execute cargas de trabalho do Autopilot em clusters padrão do GKE

Os administradores de clusters e os operadores de aplicações podem usufruir das vantagens do Google Kubernetes Engine (GKE) Autopilot, como os preços e as definições pré-configuradas, em clusters do modo Standard. Esta página mostra como usar ComputeClasses para implementar uma carga de trabalho do Autopilot num cluster padrão. Já deve estar familiarizado com os seguintes conceitos:

Acerca das ComputeClasses do Autopilot

O GKE fornece recursos personalizados do Kubernetes denominados ComputeClasses que podem ser implementados no seu cluster como quaisquer outros recursos do Kubernetes. Uma ComputeClass define uma lista de configurações de nós, como tipos de máquinas ou VMs Spot. Pode 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 executa os pods no modo Autopilot. Os nós que o GKE cria são geridos pela Google e incluem muitas das definições de segurança e funcionalidades do Autopilot predefinidas. Para mais informações sobre as implicações da execução de uma carga de trabalho do Autopilot nos seus clusters Standard, incluindo as diferenças que pode notar quando implementa essas cargas de trabalho, consulte o artigo Acerca das cargas de trabalho do modo Autopilot no GKE Standard.

Tipos de ComputeClasses do Autopilot

O GKE fornece ComputeClasses do Autopilot integradas que pode usar para a maioria das cargas de trabalho de uso geral. Também pode configurar uma ComputeClass personalizada nova ou existente para usar o modo Autopilot. O tipo de Autopilot ComputeClass que usa depende de as suas cargas de trabalho precisarem de hardware específico, da seguinte forma:

  • Cargas de trabalho de uso geral: use uma das ComputeClasses do Autopilot incorporadas, que colocam pods na plataforma de computação otimizada para contentores.
  • Cargas de trabalho que requerem hardware específico: ative o modo Autopilot para qualquer ComputeClass personalizada, implemente essa ComputeClass no cluster e selecione essa ComputeClass nas suas cargas de trabalho.

Para mais informações sobre estas opções, quando as usar e os preços de cada opção, consulte Seleção de hardware em ComputeClasses do Autopilot.

Preços

Os preços do GKE Autopilot aplicam-se às cargas de trabalho e aos nós que usam uma ComputeClass do Autopilot. O modelo de preços que se aplica depende de usar uma ComputeClass do Autopilot incorporada ou uma ComputeClass do Autopilot personalizada. Para mais informações, consulte a secção Preços em "Acerca das cargas de trabalho do modo Autopilot no GKE Standard".

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.
  • Use um cluster padrão do GKE que execute a versão 1.33.1-gke.1107000 ou posterior e esteja inscrito no canal de lançamento rápido. Para criar um novo cluster, consulte o artigo Criar um cluster regional.
  • Para evitar rejeições de cargas de trabalho, saiba mais sobre os requisitos e as restrições de segurança do Autopilot. Para mais informações, consulte as definições predefinidas para nós do Autopilot.

Requisitos

  • Pelo menos, um conjunto de nós no cluster não pode ter contaminações de nós.

    Este conjunto de nós é necessário para executar pods do sistema padrão do GKE que não podem ser executados em nós do Autopilot em clusters padrão devido às restrições que o GKE adiciona a esses nós.

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

  • Tem de usar um cluster nativo de VPC.

Limitações

  • Apenas o canal de lançamento rápido é suportado.
  • Para atualizar os recursos ComputeClass existentes no cluster para usar o modo Autopilot, tem de recriar essa ComputeClass com uma especificação atualizada. Para mais informações, consulte o artigo Ative o Autopilot para uma ComputeClass personalizada existente.
  • Não pode usar a regra de prioridade podFamily nas suas próprias ComputeClasses. Esta regra só está disponível nas ComputeClasses do Autopilot incorporadas.
  • As ComputeClasses do Autopilot incorporadas não suportam a ativação de nós do GKE confidenciais para todo o cluster. Se ativar os nós do GKE confidenciais para o cluster, todos os novos pods que selecionem as ComputeClasses do Autopilot incorporadas permanecem no estado Pending indefinidamente.

Funções e autorizações necessárias

Para obter as autorizações de que precisa para implementar ComputeClasses, peça ao seu administrador para lhe conceder a função de IAM de programador do Kubernetes Engine (roles/container.developer) no seu cluster ou projeto . Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Selecione uma ComputeClass do Autopilot numa carga de trabalho

Para selecionar uma ComputeClass do Autopilot numa carga de trabalho, use um seletor de nós para a etiqueta cloud.google.com/compute-class. Esta é a mesma etiqueta que usa para selecionar qualquer outra ComputeClass no GKE. Os passos seguintes mostram como criar uma implementação de exemplo que seleciona uma ComputeClass e verificar se os pods são executados no modo de piloto automático:

  1. Guarde a implementação de exemplo seguinte 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 usar. Este valor pode ser qualquer uma das seguintes opções:

  2. Implemente a carga de trabalho:

    kubectl apply -f autopilot-cc-deployment.yaml

  3. Para verificar se os pods usam o Autopilot, verifique os nomes dos nós anfitriões:

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

    O resultado é semelhante ao 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>

    Nesta saída, o prefixo gk3- na coluna Node indica que o nó é gerido pelo Autopilot.

Configure uma ComputeClass do Autopilot personalizada

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

Se as suas cargas de trabalho não exigirem hardware específico, recomendamos que use uma das ComputeClasses do Autopilot incorporadas. Para selecionar uma ComputeClass do Autopilot integrada, consulte a secção Selecione uma ComputeClass do Autopilot numa carga de trabalho anterior.

Crie uma nova ComputeClass personalizada do Autopilot

  1. Guarde o seguinte exemplo de manifesto 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

    Este manifesto inclui os seguintes campos:

    • autopilot: ativa o modo de piloto automático para a ComputeClass. Se especificar este campo numa ComputeClass que implementa num cluster do Autopilot, o GKE ignora 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 que o GKE use uma das regras no campo priorities para novos nós. Se nenhuma destas regras de prioridade puder ser cumprida, o GKE deixa o pod num estado Pending até que os recursos estejam disponíveis. DoNotScaleUp é o valor predefinido e recomendado para este campo.

  2. Implemente a ComputeClass:

    kubectl apply -f autopilot-n2-class.yaml

  3. Verifique se a ComputeClass existe:

    kubectl get computeclasses

    O resultado é semelhante ao seguinte:

    NAME                  AGE
autopilot-n2-class    3s

Ative o Autopilot para uma ComputeClass personalizada existente

Pode ativar o Autopilot em ComputeClasses personalizadas existentes que estejam num cluster Standard e tenham o campo nodePoolAutoCreation.enabled na especificação definido como true. A ativação do Autopilot numa classe de computação que esteja num cluster do Autopilot não tem efeito, porque todo o cluster usa o modo Autopilot.

Depois de ativar o Autopilot para uma ComputeClass existente, o GKE usa o Autopilot para executar novos pods que selecionam a ComputeClass. Se tiver pods existentes em nós padrão que selecionem a ComputeClass do Autopilot, esses pods usam o Autopilot apenas quando são recriados.

Para atualizar uma ComputeClass personalizada existente para usar o modo Autopilot, siga estes passos:

  1. Num editor de texto, atualize o ficheiro de manifesto da ComputeClass existente para adicionar o campo spec.autopilot:

    spec:
  autopilot:
    enabled: true

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

    kubectl replace --force -f PATH_TO_UPDATED_MANIFEST

    Substitua PATH_TO_UPDATED_MANIFEST pelo caminho para o ficheiro 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 nós novos que o GKE criar para esta ComputeClass usam o Autopilot. O GKE não modifica os nós existentes criados antes da atualização.

Valide se a sua carga de trabalho usa o Autopilot

  • Aceda a uma lista dos pods no seu cluster através do comando kubectl get:

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

    O resultado é semelhante ao seguinte:

    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á a ser executado no modo Autopilot.

Aplique uma ComputeClass do Autopilot por predefinição

O GKE permite-lhe definir uma ComputeClass como predefinição para um espaço de nomes. A classe predefinida do espaço de nomes aplica-se a todos os pods nesse espaço de nomes que não selecionem explicitamente uma ComputeClass diferente. Definir uma ComputeClass do Autopilot como predefinição significa que pode executar todos os pods num espaço de nomes no modo Autopilot por predefinição, a menos que a carga de trabalho selecione uma opção diferente.

Para mais informações, consulte o artigo Configure uma ComputeClass predefinida para um espaço de nomes.

O que se segue?