Implementa cargas de trabajo de Autopilot en la arquitectura Arm

Autopilot

En esta página, se muestra cómo configurar las implementaciones de Google Kubernetes Engine (GKE) Autopilot para solicitar nodos que están respaldados por la arquitectura Arm.

Acerca de la arquitectura Arm en Autopilot

Los clústeres de Autopilot ofrecen clases de procesamiento para las cargas de trabajo que tienen requisitos de hardware específicos. Algunas de estas clases de procesamiento admiten varias arquitecturas de CPU, como amd64 y arm64.

Casos de uso para nodos Arm

Los nodos con arquitectura Arm ofrecen un rendimiento más rentable que los nodos x86 similares. Debes seleccionar Arm para tus cargas de trabajo de Autopilot en situaciones como las siguientes:

• Tu entorno depende de la arquitectura Arm para la compilación las pruebas.
• Estás desarrollando aplicaciones para dispositivos Android que se ejecutan en CPU Arm.
• Usas imágenes multiarquitectura y deseas optimizar los costos mientras ejecutas las cargas de trabajo.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

• Habilita la API de Google Kubernetes Engine.
Habilitar la API de Google Kubernetes Engine
• Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa the gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos de este documento.
  Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar la compute/region propiedad. Si usas principalmente clústeres zonales, configura compute/zone en su lugar. Cuando configuras una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que debas especificar la ubicación en ciertos comandos si la ubicación de tu clúster difiere de la predeterminada que estableciste.

• Revisa los requisitos y las limitaciones de los nodos Arm.

Requisitos

• Para usar la ComputeClass autopilot-arm, asegúrate de que tu clúster ejecute la versión 1.35.3-gke.1389000 de GKE o una posterior.
• Para usar funciones como la configuración predeterminada inteligente (especificando solo la kubernetes.io/arch: arm64 etiqueta), la autopilot-arm-spot ComputeClass, o la autopilot-arm ComputeClass en clústeres Standard de GKE que usan ComputeClasses de Autopilot, tu clúster debe ejecutar la versión 1.36.0-gke.3302001 o una posterior.
• Asegúrate de tener una cuota para los C4A, N4A, o Tau T2A tipos de máquinas de Compute Engine.
• Asegúrate de tener un Pod con una imagen de contenedor compilada para la arquitectura Arm.

Cómo solicitar nodos Arm en Autopilot

Para indicarle a Autopilot que ejecute tus Pods en nodos Arm, especifica uno de los siguientes selectores (según el tipo y la versión de GKE) con un nodeSelector o regla de afinidad de nodos:

• En clústeres de Autopilot (configuración predeterminada inteligente): Especifica solo el tipo de arquitectura:

  • kubernetes.io/arch: arm64

  Si tu carga de trabajo se ejecuta en un clúster de Autopilot, se selecciona la plataforma Arm de uso general.

• En clústeres de Autopilot o clústeres Standard que usan ComputeClasses de Autopilot (solo ComputeClass): Especifica la ComputeClass:

  • cloud.google.com/compute-class: autopilot-arm (o autopilot-arm-spot)

  Si seleccionas esta clase, se programa tu carga de trabajo en la plataforma Arm optimizada para contenedores (o su variante de VMs interrumpibles) y se agrega automáticamente el selector kubernetes.io/arch: arm64 requerido al Pod durante la admisión.

• Selección explícita (versiones anteriores de GKE): En los clústeres de Autopilot que ejecutan la versión 1.35.3-gke.1389000 o una posterior, pero anterior a la 1.36.0-gke.3302001, especifica los siguientes selectores para seleccionar la plataforma Arm de uso general. Esta combinación también es compatible con versiones más recientes de GKE para la retrocompatibilidad:

  • cloud.google.com/compute-class: autopilot-arm
  • kubernetes.io/arch: arm64

• Para cargas de trabajo con requisitos de hardware específicos: Especifica una de las siguientes opciones:

  • kubernetes.io/arch: arm64 en un clúster Standard. De forma predeterminada, GKE coloca los Pods en tipos de máquinas C4A.
  • cloud.google.com/machine-family: ARM_MACHINE_SERIES. Reemplaza ARM_MACHINE_SERIES por una serie de máquinas Arm como C4A, N4A, o T2A. GKE coloca Pods en la serie especificada.

De forma predeterminada, si usas cualquiera de las etiquetas, excepto Performance, GKE coloca otros Pods en el mismo nodo si hay capacidad de disponibilidad en ese nodo. Para solicitar un nodo dedicado para cada Pod, agrega la etiqueta cloud.google.com/compute-class: Performance a tu manifiesto junto con las etiquetas de arquitectura o familia de máquinas. Para obtener más detalles, consulta Cómo optimizar el rendimiento de los Pods de Autopilot eligiendo una serie de máquinas.

También puedes usar la etiqueta Scale-Out con la etiqueta arm64 para solicitar T2A. También puedes solicitar la arquitectura Arm para Pods Spot.

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

1. Aprovisiona de forma automática los nodos Arm para ejecutar tus Pods.
2. Genera un taint de forma automática en los nodos nuevos para evitar que se programen Pods que no sean de Arm en esos nodos.
3. Agrega de forma automática una tolerancia a tus Pods de Arm para permitir la programación en los nodos nuevos.

Nota: Puedes configurar el taint predeterminado de la arquitectura Arm para los grupos de nodos Standard, y las ComputeClasses personalizadas. Si actualizas los taints con estos métodos, no se verán afectados los nodos que GKE crea para las ComputeClasses de Arm de Autopilot integradas. No puedes modificar el comportamiento del taint de la arquitectura Arm para esas ComputeClasses integradas.

Solicitud de ejemplo de la arquitectura Arm

En las siguientes especificaciones de ejemplo, se muestra cómo usar un selector de nodos o una regla de afinidad de nodos para solicitar la arquitectura Arm en Autopilot.

nodeSelector

En el siguiente manifiesto de ejemplo, se solicita un nodo Arm optimizado para contenedores de Autopilot con la configuración predeterminada inteligente:

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:
        kubernetes.io/arch: arm64
      containers:
      - name: nginx-arm
        image: nginx
        resources:
          requests:
            cpu: 2000m
            memory: 2Gi

Como alternativa, puedes solicitar la plataforma Arm optimizada para contenedores especificando de forma explícita la autopilot-arm (o autopilot-arm-spot para VMs interrumpibles) ComputeClass:

...
    spec:
      nodeSelector:
        cloud.google.com/compute-class: autopilot-arm
...

Para solicitar hardware específico en lugar de nodos optimizados para contenedores de Autopilot, reemplaza las ComputeClasses o agrega cloud.google.com/machine-family: C4A a tu selector.

nodeAffinity

Puedes usar la afinidad de nodos para solicitar nodos Arm.

En el siguiente manifiesto de ejemplo, se solicita un nodo Arm optimizado para contenedores de Autopilot con la configuración predeterminada inteligente:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-arm
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-arm
  template:
    metadata:
      labels:
        app: nginx-arm
    spec:
      terminationGracePeriodSeconds: 25
      containers:
      - name: nginx-arm
        image: nginx
        resources:
          requests:
            cpu: 2000m
            memory: 2Gi
            ephemeral-storage: 1Gi
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values:
                - arm64

Para solicitar hardware específico en lugar de nodos optimizados para contenedores de Autopilot, reemplaza kubernetes.io/arch por reglas de afinidad de familia de máquinas específicas o solicita clases como Performance o Scale-Out.

Recomendaciones

• Compila y usa imágenes multiarquitectura como parte de tu canalización. Las imágenes multiarquitectura garantizan que tus Pods se ejecuten incluso si se colocan en nodos x86.
• Solicita arquitectura y clases de procesamiento de forma explícita en tus manifiestos de cargas de trabajo. Si no lo haces, Autopilot usa la arquitectura predeterminada de la clase de procesamiento seleccionada, que podría no ser Arm.

Disponibilidad

Puedes implementar cargas de trabajo de Autopilot en la arquitectura Arm en las siguientes regiones: us-east1, us-west1, europe-west1, europe-west2, europe-west4, asia-southeast1 y us-central1.

Soluciona problemas

Para obtener información sobre la solución de problemas y errores comunes, consulta Solución de problemas de cargas de trabajo de Arm.

¿Qué sigue?

• Obtén más información sobre la arquitectura del clúster de Autopilot.
• Obtén más información sobre el ciclo de vida de los Pods.
• Obtén más información sobre las clases de procesamiento de Autopilot disponibles.
• Lee acerca de las solicitudes de recursos predeterminadas, mínimas y máximas para cada plataforma.