Esta página foi traduzida pela API Cloud Translation.

Aplicar classes de computação aos pods por padrão

Autopilot Standard

Nesta página, mostramos como aplicar classes de computação por padrão aos pods do Google Kubernetes Engine (GKE) que não selecionam explicitamente uma classe de computação. Nesta página, há instruções para definir uma classe de computação como padrão em um namespace e em um cluster inteiro. Estas instruções são destinadas a administradores de cluster que querem reduzir o overhead manual causado pela configuração individual de carga de trabalho e de nó.

Antes de ler esta página, conheça as classes de computação personalizadas.

Sobre as classes de computação padrão

É possível configurar clusters do GKE ou namespaces específicos para ter uma classe de computação padrão. A classe padrão configurada se aplica a qualquer pod no cluster ou namespace que não selecionar uma classe de computação diferente. Quando você implanta um pod que não seleciona uma classe de computação, o GKE aplica classes de computação padrão na seguinte ordem:

Se o namespace tiver uma classe de computação padrão, o GKE vai modificar a especificação do pod para selecionar essa classe.
Se o namespace não tiver uma classe de computação padrão, a classe padrão no nível do cluster será aplicada. O GKE não modifica a especificação de pod.

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.
Observação: em instalações prévias da gcloud CLI, defina a propriedade compute/region. Se você usa principalmente clusters zonais, defina compute/zone. Ao definir um local padrão, é possível evitar erros na gcloud CLI como: One of [--zone, --region] must be supplied: Please specify location. Talvez seja necessário especificar o local em determinados comandos se o local do cluster for diferente do padrão definido.

Ter um cluster do GKE Autopilot ou Standard que execute uma versão compatível com a definição de uma classe de computação padrão no nível do cluster ou do namespace. Para mais informações, consulte a seção Requisitos.

Para clusters padrão, ative o provisionamento automático de nós ou o escalonador automático de cluster.
Se quiser definir uma classe de computação personalizada como padrão para um namespace, implante uma classe de computação personalizada.

Requisitos

Para definir uma classe de computação como padrão no nível do cluster, ele precisa executar a versão 1.33.1-gke.1744000 ou mais recente do GKE.
Para definir uma classe de computação como padrão no nível do namespace apenas para pods que não sejam DaemonSets, o cluster precisa executar o GKE versão 1.33.1-gke.1788000 ou posterior.

Papéis e permissões necessárias

Para receber as permissões necessárias para configurar classes de computação padrão no nível do cluster ou do namespace, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto Google Cloud :

Desenvolvedor do Kubernetes Engine (roles/container.developer)
Atualize a classe de computação padrão no nível do cluster: Administrador de cluster do Kubernetes Engine (roles/container.clusterAdmin)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esses papéis predefinidos contêm as permissões necessárias para configurar classes de computação padrão no nível do cluster ou do namespace. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para configurar classes de computação padrão no nível do cluster ou do namespace:

container.customResourceDefinitions.create
container.customResourceDefinitions.update
container.customResourceDefinitions.get
container.customResourceDefinitions.list
container.namespaces.get
container.namespaces.list
container.pods.get
container.nodes.get
container.nodes.list
container.deployments.create
container.deployments.get
Adicione rótulos aos namespaces: container.namespaces.update
Ative a classe de computação padrão no nível do cluster: container.clusters.update

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

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

É possível adicionar anotações a qualquer namespace do Kubernetes no cluster com o nome de uma classe de computação para usar como padrão. Se um pod implantado nesse namespace ainda não tiver selecionado uma classe de computação, o GKE vai modificar a especificação do pod para selecionar a classe padrão no namespace. É possível definir qualquer classe de computação personalizada ou integrada como padrão.

Para aplicar uma classe de computação a todos os pods em um namespace por padrão, adicione o rótulo cloud.google.com/default-compute-class a esse namespace:
```
kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class=COMPUTECLASS_NAME
```
Substitua:
- NAMESPACE_NAME: o nome do namespace a ser atualizado.
- COMPUTECLASS_NAME: o nome da classe de computação a ser definida como padrão para o namespace.
Se o comando falhar com a seguinte mensagem de erro, o namespace já terá uma classe de computação padrão:
```
error: 'cloud.google.com/default-compute-class' already has a value, and --overwrite is false
```
Para resolver esse erro, atualize a classe de computação padrão do namespace.
Para aplicar uma classe de computação a todos os pods que não são DaemonSet em um namespace por padrão, adicione o rótulo cloud.google.com/default-compute-class-non-daemonset a esse namespace:
```
kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class-non-daemonset=COMPUTECLASS_NAME
```
Se o comando falhar com a seguinte mensagem de erro, o namespace já terá uma classe de computação padrão para pods que não são DaemonSet:
```
error: 'cloud.google.com/default-compute-class-non-daemonset' already has a value, and --overwrite is false
```
Para resolver esse erro, atualize a classe de computação padrão do namespace.

Atualizar a classe de computação padrão em um namespace

Para substituir a classe de computação padrão atual de um namespace, execute um dos seguintes comandos:

Atualize a classe de computação padrão para todos os pods no namespace:
```
kubectl label namespaces NAMESPACE_NAME   \
    cloud.google.com/default-compute-class=COMPUTECLASS_NAME \
    --overwrite
```
Substitua:
- NAMESPACE_NAME: o nome do namespace a ser atualizado.
- COMPUTECLASS_NAME: o nome da classe de computação a ser definida como o novo padrão para o namespace.

Substitua a classe de computação padrão para pods que não são do DaemonSet no namespace:

kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class-non-daemonset=COMPUTECLASS_NAME \
    --overwrite

Configurar uma classe de computação padrão para um cluster

Esta seção mostra como definir uma classe de computação como padrão para seu cluster. Para classes de computação padrão no nível do cluster, não especifique manualmente taints e rótulos de nós para pools de nós atuais no cluster. O GKE não escalona pools de nós com taints de nós para classes de computação. Se você adicionar manualmente um rótulo para a classe de computação default, o GKE poderá escalonar esse pool de nós. No entanto, essa configuração manual não é necessária para usar uma classe de computação padrão no nível do cluster.

Para ativar a definição de uma classe de computação padrão no nível do cluster, execute o comando gcloud container clusters update com a sinalização --enable-default-compute-class:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-default-compute-class
```
Substitua:
- CLUSTER_NAME: o nome do cluster.
- CONTROL_PLANE_LOCATION: o local do plano de controle do cluster, como us-central1.
Também é possível especificar essa flag ao criar um cluster do Autopilot ou Standard.
Salve o manifesto a seguir, que define um ComputeClass chamado default:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: default
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: n2
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
Este manifesto de exemplo solicita nós que usam instâncias N4. Se as instâncias N4 não estiverem disponíveis, a classe de computação vai solicitar instâncias N2. É possível configurar a classe de computação default com qualquer um dos campos disponíveis na definição de recurso personalizado ComputeClass.
Aplique o manifesto ao cluster:
```
kubectl apply -f PATH_TO_MANIFEST
```
Substitua PATH_TO_MANIFEST pelo caminho para o manifesto da classe de computação.

Depois de definir uma classe de computação padrão no nível do cluster, o GKE dimensiona os pools de nós que atendem aos dois requisitos a seguir:

A configuração do nó é a mesma da classe de computação default.
O pool de nós não tem restrições ou rótulos para uma classe de computação diferente. O GKE pode escalonar pools de nós que têm um taint e um rótulo para a classe de computação default.

Por exemplo, se a classe de computação default especificar a série de máquinas N4, o GKE poderá escalonar um pool de nós atual que usa instâncias N4 e não tem taints ou rótulos para uma classe de computação diferente.

Verificar o comportamento padrão da classe de computação

Para verificar se a classe de computação padrão definida para um namespace ou para um cluster funciona conforme o esperado, faça o seguinte:

Analise o exemplo de implantação a seguir:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloweb
  labels:
    app: hello
spec:
  selector:
    matchLabels:
      app: hello
      tier: web
  template:
    metadata:
      labels:
        app: hello
        tier: web
    spec:
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 200m

Essa implantação não solicita explicitamente uma classe de computação.

Crie a implantação:
```
kubectl apply --namespace=NAMESPACE_NAME \
    -f https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/quickstarts/hello-app/manifests/helloweb-deployment.yaml
```
Substitua NAMESPACE_NAME por uma das seguintes opções, dependendo do que você quer verificar:
- O nome de um namespace que tem uma classe de computação padrão.
- O nome de um namespace que não tem uma classe de computação padrão.
O GKE pode levar algum tempo para criar novos nós para executar os pods.

Identifique os nós que executam os pods da implantação de exemplo:

kubectl get pods --namespace=NAMESPACE_NAME \
    --selector=app=hello -o=wide

O resultado será assim:

NAME                        READY   STATUS    RESTARTS   AGE     IP          NODE                                                  NOMINATED NODE   READINESS GATES
helloweb-7795fbf856-58n5l   1/1     Running   0          9m21s   10.52.2.3   gke-cluster-1-nap-n2-highcpu-2-3muqi8-f213e529-rx7d   <none>           <none>

Acesse os rótulos do nó:
```
kubectl get node NODE_NAME --show-labels \
    | grep "cloud.google.com/compute-class"
```
Substitua NODE_NAME pelo nome do nó da saída da etapa anterior.

O resultado será assim:
```
NODE_NAME   Ready    <none>   22m   v1.32.4-gke.1236007
# lines are omitted from this output
cloud.google.com/compute-class=COMPUTECLASS_NAME,cloud.google.com/gke-boot-disk=pd-balanced,cloud.google.com/gke-container-runtime=containerd
```
O valor em COMPUTECLASS_NAME é um dos seguintes:
- Classe de computação padrão no nível do cluster: default para nós criados pelo GKE Autopilot ou pelo provisionamento automático de nós. Os nós em pools de nós criados manualmente podem não ter o rótulo cloud.google.com/compute-class.
- Classe de computação padrão no nível do namespace: o nome da classe de computação que você configurou como padrão do namespace.

Desativar a classe de computação padrão

Para desativar a classe de computação padrão em um namespace ou cluster, faça uma das seguintes ações:

Para desativar a classe de computação padrão no nível do namespace para todos os pods, remova o rótulo cloud.google.com/default-compute-class do namespace:
```
kubectl label namespaces NAMESPACE_NAME \
  cloud.google.com/default-compute-class-
```
O caractere - no final da chave do rótulo remove todos os rótulos com essa chave do objeto Namespace na API Kubernetes.
Para desativar a classe de computação padrão no nível do namespace para pods que não são DaemonSet, remova o rótulo cloud.google.com/default-compute-class-non-daemonset do namespace:
```
kubectl label namespaces NAMESPACE_NAME \
  cloud.google.com/default-compute-class-non-daemonset-
```
Para desativar a classe de computação padrão no nível do cluster, use o comando gcloud container clusters update com a flag --no-enable-default-compute-class:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-default-compute-class
```

A seguir

Saiba mais sobre as classes de computação personalizadas no GKE.