Nesta página, descrevemos as classes de computação que podem ser usadas para executar cargas de trabalho do Autopilot do Google Kubernetes Engine (GKE) com requisitos de hardware específicos. Para ver instruções, consulte Executar pods do Autopilot em classes de computação específicas.
Visão geral das classes de computação do Autopilot
Por padrão, os pods do Autopilot do GKE são executados em uma plataforma de computação otimizada para cargas de trabalho de uso geral, como exibição na Web e jobs em lote de intensidade média. Essa plataforma geral fornece uma configuração de hardware confiável e otimizada para custos que atende aos requisitos da maioria das cargas de trabalho.
Se você tiver cargas de trabalho com requisitos de hardware exclusivos, como a execução
de tarefas de machine learning ou IA, a execução de bancos de dados de alto tráfego em tempo real ou
a necessidade de plataformas e arquitetura de CPU específicas, o Autopilot oferece
classes de computação. Essas classes de computação são um subconjunto selecionado da
série de máquinas do
Compute Engine e oferecem flexibilidade
além da classe de computação padrão do Autopilot. Por exemplo,
a classe de computação Scale-Out usa VMs que desativam várias linhas de execução simultâneas e
são otimizadas para escalonamento horizontal.
É possível solicitar nós baseados em classes de computação específicas com base nos requisitos de cada uma das cargas de trabalho. Semelhante à classe de computação de uso geral padrão, o Autopilot gerencia o dimensionamento e a alocação de recursos das classes de computação solicitadas com base nos pods em execução. É possível solicitar classes de computação no nível do pod para otimizar o custo-benefício. Basta escolher a melhor opção para as necessidades de cada pod.
Escolher uma arquitetura de CPU específica
Se as cargas de trabalho forem projetadas para plataformas ou arquiteturas de CPU específicas, será possível selecionar essas plataformas ou arquiteturas nas especificações do pod. Por exemplo, se você quiser que seus pods sejam executados em nós que usam a
arquitetura do Arm, escolha arm64 dentro da classe de computação Scale-Out.
Preços
Os pods do Autopilot do GKE são cobrados com base nos nós em que os pods estão programados. Para informações sobre preços de cargas de trabalho de uso geral e pods do Spot em classes de computação específicas e informações sobre descontos de uso comprometido, consulte os preços do modo Autopilot.
Os pods do Spot em classes de computação de uso geral ou especializadas não se qualificam para descontos por uso contínuo.
Quando usar classes de computação específicas
A tabela a seguir apresenta uma visão geral técnica das classes de computação compatíveis com o Autopilot e exemplos de casos de uso de pods em execução em cada plataforma. Se você não solicitar uma classe de computação, o Autopilot colocará os pods na plataforma de computação de uso geral, projetada para executar a maioria das cargas de trabalho de maneira ideal.
Se nenhuma dessas opções atender aos seus requisitos, defina e implante suas próprias classes de computação personalizadas que especificam as propriedades do nó para que o GKE as use ao escalonar verticalmente o cluster. Para mais detalhes, consulte Sobre as classes de computação personalizadas.
| Requisito de carga de trabalho | Classe do computação | Descrição | Casos de uso de exemplo |
|---|---|---|---|
| Cargas de trabalho que não exigem hardware específico | Uso geral |
O Autopilot usará a plataforma de computação de uso geral se você não solicitar explicitamente uma classe de computação na especificação do pod. Não é possível selecionar explicitamente a plataforma de uso geral na especificação. Apoiado pela série de máquinas E2. |
|
| Cargas de trabalho que exigem GPUs | Accelerator |
Os tipos de GPU compatíveis são estes:
|
|
| Solicitações de CPU ou memória maiores que os níveis máximos de classe de computação de uso geral ou plataformas de CPU específicas | Balanced |
Com apoio da série de máquinas N2 (Intel) ou da série de máquinas N2D (AMD). |
|
| Cargas de trabalho com requisitos para séries de máquinas específicas que não são cobertas por outras classes de computação | Séries de máquinas específicas |
Para mais detalhes, consulte Otimizar o desempenho do pod do Autopilot escolhendo uma série de máquinas. |
|
| Cargas de trabalho com uso intensivo de CPU, como treinamento de IA/ML ou computação de alto desempenho (HPC) | Performance |
Para uma lista das séries de máquinas do Compute Engine disponíveis com a classe de computação de desempenho, consulte Séries de máquinas compatíveis. |
|
| Computação por núcleo único e escalonamento horizontal | Scale-Out |
Com apoio da série de máquinas Tau T2A (Arm) ou da série de máquinas Tau T2D (x86). |
|
Como selecionar uma classe de computação no Autopilot
Para instruções detalhadas, consulte Escolher classes de computação para pods do Autopilot.
Para instruir o Autopilot a colocar seus pods em uma classe de computação específica, especifique o rótulocloud.google.com/compute-class em um
nodeSelector
ou em uma regra de afinidade de nó, como nos exemplos a seguir:
nodeSelector
apiVersion: apps/v1 kind: Deployment metadata: name: hello-app spec: replicas: 3 selector: matchLabels: app: hello-app template: metadata: labels: app: hello-app spec: nodeSelector: cloud.google.com/compute-class: "COMPUTE_CLASS" containers: - name: hello-app image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 resources: requests: cpu: "2000m" memory: "2Gi"
Substitua COMPUTE_CLASS pelo nome da
classe de computação
com base no seu caso de uso, como Scale-Out.
Se você selecionar Accelerator, também precisará especificar uma GPU compatível. Para ver instruções, consulte Implantar cargas de trabalho da GPU no Autopilot. Se você selecionar Performance, também precisará escolher uma série de máquinas do Compute Engine no seletor de nós. Para instruções, consulte Executar cargas de trabalho com uso intensivo da CPU com o desempenho ideal.
nodeAffinity
apiVersion: apps/v1 kind: Deployment metadata: name: hello-app spec: replicas: 3 selector: matchLabels: app: hello-app template: metadata: labels: app: hello-app spec: terminationGracePeriodSeconds: 25 containers: - name: hello-app image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 resources: requests: cpu: "2000m" memory: "2Gi" ephemeral-storage: "1Gi" affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: cloud.google.com/compute-class operator: In values: - "COMPUTE_CLASS"
Substitua COMPUTE_CLASS pelo nome da
classe de computação
com base no seu caso de uso, como Scale-Out. Se você selecionar Accelerator, também precisará especificar uma GPU compatível. Para ver instruções, consulte Implantar cargas de trabalho da GPU no Autopilot. Se você selecionar Performance, também precisará escolher uma série de máquinas do Compute Engine no seletor de nós. Para instruções, consulte Executar cargas de trabalho com uso intensivo da CPU com o desempenho ideal.
Quando você implanta a carga de trabalho, o Autopilot faz o seguinte:
- Provisiona automaticamente os nós com a configuração especificada para executar seus pods.
- Adiciona automaticamente taints aos novos nós para evitar que outros pods sejam programados neles. Os taints são exclusivos de cada classe de computação. Se você também selecionar uma arquitetura de CPU, o GKE adicionará um taint exclusivo a ela.
- Adiciona automaticamente tolerâncias correspondentes aos taints aplicados aos pods implantados, permitindo que o GKE coloque esses pods nos novos nós.
Por exemplo, se você solicitar a classe de computação Scale-Out para um pod:
- O Autopilot adiciona um taint específico para
Scale-Outpara esses nós. - O Autopilot adiciona uma tolerância a esse taint aos pods
Scale-Out.
Os pods que não solicitarem Scale-Out não receberão a tolerância. Como resultado,
o GKE não programará esses pods nos nós Scale-Out.
Se você não solicitar explicitamente uma classe de computação na especificação da carga de trabalho, o Autopilot programará os pods nos nós que usam a classe de computação de uso geral padrão. A maioria das cargas de trabalho pode ser executada sem problemas na classe de computação de uso geral.
Como solicitar uma arquitetura de CPU
Em alguns casos, as cargas de trabalho podem ser criadas para uma arquitetura específica, como Arm. Algumas classes de computação, como equilibrada ou de escalonamento horizontal, são compatíveis com várias arquiteturas de CPU. É possível solicitar uma arquitetura específica junto com a solicitação de classe do Compute especificando o rótulo no seletor de nós ou na regra de afinidade do nó, como no exemplo a seguir:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-arm
spec:
replicas: 3
selector:
matchLabels:
app: nginx-arm
template:
metadata:
labels:
app: nginx-arm
spec:
nodeSelector:
cloud.google.com/compute-class: COMPUTE_CLASS
kubernetes.io/arch: ARCHITECTURE
containers:
- name: nginx-arm
image: nginx
resources:
requests:
cpu: 2000m
memory: 2Gi
Substitua ARCHITECTURE pela arquitetura de CPU que você
quer, como arm64 ou amd64.
Se você não solicitar explicitamente uma arquitetura, o Autopilot usará a arquitetura padrão da classe de computação especificada.
Arquitetura de braço no Autopilot
O Autopilot é compatível com solicitações de nós que usam a arquitetura de CPU Arm. Os nós de Arm têm melhor custo-benefício do que os nós x86 semelhantes, além de melhorar o desempenho. Para ver instruções sobre como solicitar nós do Arm, consulte Implantar cargas de trabalho do Autopilot na arquitetura do Arm.
Verifique se você está usando as imagens corretas nas implantações. Se os pods usarem imagens do Arm e você não solicitar nós do Arm, o Autopilot programará os pods em nós x86, e eles falharão. Da mesma forma, se você usar imagens x86 acidentalmente, mas solicitar nós do Arm para os pods, os pods falharão.
Validações de piloto automático para cargas de trabalho de classes de computação
O Autopilot valida os manifestos de cargas de trabalho para garantir que as solicitações de classe e arquitetura de computação no seletor de nós ou nas regras de afinidade de nós sejam formatadas corretamente. Aplicam-se as seguintes regras:
- Não há mais de uma classe de computação.
- Não há classes de computação incompatíveis.
- A versão do GKE precisa ser compatível com a classe de computação.
- Não há mais de uma arquitetura selecionada.
- A classe de computação precisa ser compatível com a arquitetura selecionada.
Se o manifesto da carga de trabalho falhar em qualquer uma dessas validações, o Autopilot rejeitará a carga de trabalho.
Disponibilidade regional da classe de computação
A tabela a seguir descreve as regiões em que classes de computação e arquiteturas de CPU específicas estão disponíveis:
| Disponibilidade da classe de computação | |
|---|---|
| Uso geral | Todas as regiões |
Balanced |
Todas as regiões |
Performance |
Todas as regiões que contêm uma série de máquinas com suporte. |
Scale-Out |
Todas as regiões que contêm uma série de máquinas correspondente do Compute Engine. Para consultar a disponibilidade de séries de máquinas específicas, use os filtros em Regiões e zonas disponíveis. |
Se uma classe de computação estiver disponível em uma região específica, o hardware estará disponível em pelo menos duas zonas nessa região.
Solicitações de recursos padrão, mínimas e máximas
Ao escolher uma classe de computação para suas cargas de trabalho do Autopilot, especifique as solicitações de recursos que atendem às solicitações mínima e máxima para essa classe. Para informações sobre as solicitações padrão, bem como as solicitações mínima e máxima para cada classe de computação, consulte Solicitações e limites de recursos no Autopilot do GKE.
A seguir
- Saiba como selecionar classes de computação específicas nas cargas de trabalho do Autopilot.
- Leia sobre as solicitações de recursos padrão, mínima e máxima de cada plataforma.