Clases de procesamiento en Autopilot


En esta página, se describen las clases de procesamiento que puedes usar para ejecutar las cargas de trabajo de Google Kubernetes Engine (GKE) Autopilot que tienen requisitos de hardware específicos. Para obtener instrucciones, consulta Ejecuta Pods de Autopilot en clases de procesamiento específicas.

Descripción general de las clases de procesamiento de Autopilot

De forma predeterminada, los Pods de GKE Autopilot se ejecutan en una plataforma de procesamiento optimizada para cargas de trabajo de uso general, como la entrega web y los trabajos por lotes de intensidad media. Esta plataforma general proporciona una configuración de hardware confiable y con optimización de costos que puede manejar los requisitos de la mayoría de las cargas de trabajo.

Si tienes cargas de trabajo que tienen requisitos de hardware únicos, como realizar tareas de IA o aprendizaje automático, ejecutar bases de datos de tráfico alto en tiempo real o necesitar arquitecturas y plataformas de CPU específicas, Autopilot ofrece clases de procesamiento. Estas clases de procesamiento son un subconjunto seleccionado de la serie de máquinas de Compute Engine y ofrecen flexibilidad más allá de la clase de procesamiento predeterminada de Autopilot. Por ejemplo, la clase de procesamiento Scale-Out usa VM que desactivan los subprocesos múltiples simultáneos y están optimizadas para escalar horizontalmente.

Puedes solicitar nodos respaldados por clases de procesamiento específicas según los requisitos de cada una de tus cargas de trabajo. De manera similar a la clase de procesamiento de uso general predeterminada, Autopilot administra el tamaño y la asignación de recursos de las clases de procesamiento solicitadas en función de tus Pods en ejecución. Puedes solicitar clases de procesamiento a nivel de Pod para optimizar la rentabilidad y elegir la mejor opción para las necesidades de cada Pod.

Elige una arquitectura de CPU específica

Si tus cargas de trabajo están diseñadas para plataformas o arquitecturas de CPU específicas, puedes seleccionar esas plataformas o arquitecturas en las especificaciones de tu Pod. Por ejemplo, si deseas que tus Pods se ejecuten en nodos que usan la arquitectura Arm, puedes elegir arm64 dentro de la clase de procesamiento Scale-Out.

Precios

Los precios de los Pods de GKE Autopilot se calculan según los nodos en los que se programan los Pods. A fin de obtener información sobre los precios de las cargas de trabajo de uso general y los Pods Spot en clases de procesamiento específicas, y sobre los descuentos por compromiso de uso, consulta Precios del modo Autopilot.

Los Pods Spot en clases de procesamiento de uso general o especializadas no califican para descuentos por compromiso de uso.

Cuándo usar clases de procesamiento específicas

En la siguiente tabla, se proporciona una descripción general técnica de las clases de procesamiento que admite Autopilot y ejemplos de casos de uso de Pods que se ejecutan en cada plataforma. Si no solicitas una clase de procesamiento, Autopilot coloca tus Pods en la plataforma de procesamiento de uso general, que está diseñada para ejecutar la mayoría de las cargas de trabajo de forma óptima.

Requisito de la carga de trabajo Clase de procesamiento Descripción Casos de uso de ejemplo
Cargas de trabajo que no requieren hardware específico Uso general

Autopilot usa la plataforma de procesamiento de uso general si no solicitas de manera explícita una clase de procesamiento en tu especificación de Pod.

No puedes seleccionar de manera explícita la plataforma de uso general en tu especificación.

Con el respaldo de la serie de máquinas E2.

  • Servidores web
  • Bases de datos pequeñas a medianas
  • Entornos de desarrollo
Cargas de trabajo que requieren GPU Accelerator
  • Los Pods pueden acceder a los recursos de procesamiento en cualquier momento
  • Sin memoria del Pod ni límites de CPU

Los tipos de GPU compatibles son los siguientes:

  • nvidia-h100-80gb: NVIDIA H100 (80 GB) (solo disponible con la clase de procesamiento Accelerator)
  • nvidia-a100-80gb: NVIDIA A100 (80 GB)
  • nvidia-tesla-a100: NVIDIA A100 (40 GB)
  • nvidia-l4: NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4

  • Inferencia y entrenamiento de IA/AA centradas en GPU
Solicitudes de CPU o memoria mayores que las cantidades máximas de clases de procesamiento de uso general o plataformas de CPU específicas Balanced
  • CPU disponibles: AMD EPYC Rome, AMD EPYC Milan, Intel Ice Lake, Intel Cascade Lake
  • Arquitectura disponible: amd64
  • Solicitudes de recursos compatibles más grandes que las de uso general
  • Capacidad de establecer plataformas de CPU mínimas para Pods, como “Intel Ice Lake o superior”.

Con el respaldo de las series de máquinas N2 (Intel) o las series de máquinas N2D (AMD).

  • Servidores web
  • Bases de datos medianas a grandes
  • Almacenamiento en caché
  • Transmisión y entrega de contenido multimedia
  • Capacidad de procesamiento de Hyperdisk y almacenamiento extremo
Cargas de trabajo con uso intensivo de CPU, como entrenamiento de IA/AA o computación de alto rendimiento (HPC) Performance
  • Arquitectura disponible: amd64, arm64
  • Los Pods pueden acceder a los recursos de procesamiento en cualquier momento
  • Sin memoria del Pod ni límites de CPU

Para obtener una lista de las series de máquinas de Compute Engine disponibles con la clase de procesamiento de rendimiento, consulta Series de máquinas compatibles.

  • Inferencia y entrenamiento de IA/AA centrado en la CPU
  • Cargas de trabajo por lotes de HPC
  • Almacenamiento Hyperdisk Balanced, Throughput y Extreme
Procesamiento de un solo núcleo por nodo y escalamiento horizontal Scale-Out
  • CPU disponibles: Ampere Altra Arm o AMD EPYC Milan
  • Familia de máquinas de Compute Engine: T2A (Arm), T2D (x86)
  • Arquitectura disponible: arm64 o amd64
  • SMT desactivado. Una CPU virtual equivale a un núcleo físico.
  • Máximo de 3.5 GHz de reloj

Con el respaldo de las series de máquinas Tau T2A (Arm) o las series de máquinas Tau T2D (x86).

  • Servidores web
  • Microservicios en contenedores
  • Procesamiento de registros de datos
  • Apps de Java a gran escala
  • Almacenamiento Hyperdisk Throughput

Cómo seleccionar una clase de procesamiento en Autopilot

Si deseas obtener instrucciones detalladas, consulta Elige clases de procesamiento para Pods de Autopilot.

Para indicarle a Autopilot que coloque tus Pods en una clase de procesamiento específica, especifica la etiqueta cloud.google.com/compute-class en un nodeSelector o una regla de afinidad de nodos, como en los siguientes ejemplos:

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"
    

Reemplaza COMPUTE_CLASS por el nombre de la clase de procesamiento según tu caso de uso, como Scale-Out. Si seleccionas Accelerator, también debes especificar una GPU compatible. Para obtener instrucciones, consulta Implementa cargas de trabajo de GPU en Autopilot. Si seleccionas Performance, también debes seleccionar una serie de máquinas de Compute Engine en el selector de nodos. Para obtener instrucciones, consulta Ejecuta cargas de trabajo de uso intensivo de CPU con un rendimiento óptimo.

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"
      

Reemplaza COMPUTE_CLASS por el nombre de la clase de procesamiento según tu caso de uso, como Scale-Out. Si seleccionas Accelerator, también debes especificar una GPU compatible. Para obtener instrucciones, consulta Implementa cargas de trabajo de GPU en Autopilot. Si seleccionas Performance, también debes seleccionar una serie de máquinas de Compute Engine en el selector de nodos. Para obtener instrucciones, consulta Ejecuta cargas de trabajo de uso intensivo de CPU con un rendimiento óptimo.

Cuando implementas la carga de trabajo, Autopilot hace lo siguiente:

  • Aprovisiona de forma automática los nodos respaldados por la configuración especificada para ejecutar tus Pods.
  • Agrega automáticamente taints a los nodos nuevos para evitar que otros Pods se programen en esos nodos. Los taints son únicos para cada clase de procesamiento. Si también seleccionas una arquitectura de CPU, GKE agrega un taint independiente a esa arquitectura.
  • Agrega automáticamente tolerancias correspondientes a los taints aplicados a tus Pods implementados, lo que permite que GKE coloque esos Pods en los nodos nuevos.

Por ejemplo, si solicitas la clase de procesamiento Scale-Out para un Pod:

  1. Autopilot agrega un taint específico a Scale-Out para esos nodos.
  2. Autopilot agrega una tolerancia para ese taint a los Pods Scale-Out.

Los Pods que no solicitan Scale-Out no recibirán la tolerancia. Como resultado, GKE no programará esos Pods en los nodos Scale-Out.

Si no solicitas de manera explícita una clase de procesamiento en tu especificación de carga de trabajo, Autopilot programa Pods en nodos que usan la clase de procesamiento de uso general predeterminada. La mayoría de las cargas de trabajo pueden ejecutarse sin problemas en la clase de procesamiento de uso general.

Cómo solicitar una arquitectura de CPU

En algunos casos, tus cargas de trabajo pueden compilarse para una arquitectura específica, como Arm. Algunas clases de procesamiento, como balanceada o de escalamiento horizontal, admiten varias arquitecturas de CPU. Puedes solicitar una arquitectura específica junto con tu solicitud de clase de procesamiento si especificas una etiqueta en tu selector de nodos o en la regla de afinidad de nodos, como en el siguiente ejemplo:

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

Reemplaza ARCHITECTURE por la arquitectura de CPU que desees, como arm64 o amd64.

Si no solicitas una arquitectura de manera explícita, Autopilot usa la arquitectura predeterminada de la clase de procesamiento especificada.

Arquitectura de Arm en Autopilot

Autopilot admite solicitudes de nodos que usan la arquitectura de CPU Arm. Los nodos Arm son más rentables que los nodos x86 similares y ofrecen mejoras de rendimiento. Si deseas obtener instrucciones para solicitar nodos de Arm, consulta Implementa cargas de trabajo de Autopilot en la arquitectura de Arm.

Asegúrate de usar las imágenes correctas en tus implementaciones. Si tus Pods usan imágenes de Arm y no solicitas nodos de Arm, Autopilot programa los Pods en nodos x86 y los Pods fallarán. Del mismo modo, si usas imágenes x86 por accidente, pero solicitas nodos Arm para los Pods, los Pods fallarán.

Validaciones de Autopilot para cargas de trabajo de clases de procesamiento

Autopilot valida los manifiestos de la carga de trabajo para garantizar que la clase de procesamiento y las solicitudes de arquitectura en el selector de nodos o las reglas de afinidad de nodos tengan el formato correcto. Se aplican las siguientes reglas:

  • No más de una clase de procesamiento.
  • No hay clases de procesamiento no compatibles.
  • La versión de GKE debe ser compatible con la clase de procesamiento.
  • No más de una arquitectura seleccionada.
  • La clase de procesamiento debe admitir la arquitectura seleccionada.

Si el manifiesto de tu carga de trabajo falla en alguna de estas validaciones, Autopilot rechaza la carga de trabajo.

Disponibilidad regional de la clase de procesamiento

En la siguiente tabla, se describen las regiones en las que están disponibles las clases de procesamiento y arquitecturas de las CPU específicas:

Disponibilidad de la clase de procesamiento
Uso general Todas las regiones
Balanced Todas las regiones
Performance Todas las regiones que contienen una serie de máquinas compatible.
Scale-Out

Arquitectura arm (arm64)

  • asia-southeast1
  • europe-west4
  • us-central1

Arquitectura x86 (amd64):

  • asia-east1
  • asia-southeast1
  • australia-southeast1
  • europe-west1
  • europe-west2
  • europe-west3
  • europe-west4
  • southamerica-east1
  • us-central1
  • us-east1
  • us-east4
  • us-west1
  • us-west4

Si una clase de procesamiento está disponible en una región específica, el hardware está disponible en al menos dos zonas en esa región.

Solicitudes de recursos predeterminadas, mínimas y máximas

Cuando elijas una clase de procesamiento para tus cargas de trabajo de Autopilot, asegúrate de especificar solicitudes de recursos que cumplan con las solicitudes mínimas y máximas de esa clase de procesamiento. A fin de obtener información sobre las solicitudes predeterminadas y las solicitudes mínimas y máximas para cada clase de procesamiento, consulta Solicitudes y límites de recursos en GKE Autopilot.

¿Qué sigue?