Desplegar cargas de trabajo de Autopilot en la arquitectura Arm

En esta página se muestra cómo configurar tus despliegues de Autopilot de Google Kubernetes Engine (GKE) para solicitar nodos que tengan una arquitectura basada en Arm.

Información sobre la arquitectura Arm en Autopilot

Los clústeres Autopilot ofrecen clases de computación para cargas de trabajo que tienen requisitos de hardware específicos. Algunas de estas clases de cálculo admiten varias arquitecturas de CPU, como amd64 y arm64.

Casos prácticos de 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 se basa en la arquitectura Arm para compilar y probar.
  • Estás desarrollando aplicaciones para dispositivos Android que se ejecutan en CPUs Arm.
  • Usas imágenes de varias arquitecturas y quieres optimizar los costes al ejecutar tus cargas de trabajo.

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
    • Habilitar la API de Google Kubernetes Engine
  • Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la CLI de gcloud, obtén la versión más reciente ejecutando el comando gcloud components update. Es posible que las versiones anteriores de la interfaz de línea de comandos de gcloud no admitan la ejecución de los comandos de este documento.

Cómo solicitar nodos Arm en Autopilot

Para indicar a Autopilot que ejecute tus pods en nodos Arm, especifica una de las siguientes etiquetas en una regla nodeSelector o nodeAffinity:

  • kubernetes.io/arch: arm64. GKE coloca los pods en C4A tipos de máquina de forma predeterminada en los clústeres que ejecutan la versión 1.31.3-gke.1056000 y posteriores. Si el clúster ejecuta una versión anterior, GKE coloca los pods en tipos de máquina T2A.
  • cloud.google.com/machine-family: ARM_MACHINE_SERIES. Sustituye ARM_MACHINE_SERIES por una máquina Arm de la serie C4A o T2A. GKE coloca los pods en la serie especificada.

De forma predeterminada, si se usa cualquiera de las etiquetas, GKE puede colocar otros pods en el mismo nodo si hay capacidad disponible en ese nodo. Para solicitar un nodo dedicado para cada pod, añade la etiqueta cloud.google.com/compute-class: Performance a tu manifiesto. Para obtener más información, consulta Optimizar el rendimiento de Autopilot Pod 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 los pods esporádicos.

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

  1. Aprovisiona automáticamente nodos Arm para ejecutar tus pods.
  2. Marca automáticamente los nodos nuevos para evitar que se programen pods que no sean de Arm en esos nodos.
  3. Añade automáticamente una tolerancia a tus pods de Arm para permitir la programación en los nuevos nodos.

Solicitud de ejemplo para 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 ejemplo de archivo de manifiesto se muestra cómo solicitar nodos Arm en un nodeSelector:

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

nodeAffinity

Puedes usar la afinidad de nodos para solicitar nodos Arm. También puedes especificar el tipo de afinidad de nodo que quieres usar:

  • requiredDuringSchedulingIgnoredDuringExecution: Debe usar la clase y la arquitectura de proceso especificadas.
  • preferredDuringSchedulingIgnoredDuringExecution: usa la clase y la arquitectura de computación especificadas en función de la máxima capacidad. Por ejemplo, si un nodo x86 ya está asignado, GKE coloca tu pod en el nodo x86 en lugar de aprovisionar un nuevo nodo Arm. Si no usas un manifiesto de imagen de varias arquitecturas, tu pod fallará. Te recomendamos que solicites explícitamente la arquitectura específica que quieras.

El siguiente ejemplo de manifiesto requiere la clase Performance y los nodos Arm:

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: cloud.google.com/compute-class
                operator: In
                values:
                - Performance
              - key: kubernetes.io/arch
                operator: In
                values:
                - arm64

Recomendaciones

  • Crea y usa imágenes multiarquitectura como parte de tu flujo de procesamiento. Las imágenes de varias arquitecturas aseguran que tus pods se ejecuten aunque se coloquen en nodos x86.
  • Solicita explícitamente las clases de arquitectura y de computación en los manifiestos de tus cargas de trabajo. Si no lo haces, Autopilot usará la arquitectura predeterminada de la clase de computación seleccionada, que puede que no sea Arm.

Disponibilidad

Puedes desplegar cargas de trabajo de Autopilot en la arquitectura Arm enGoogle Cloud ubicaciones que admitan la arquitectura Arm. Para obtener más información, consulta Regiones y zonas disponibles.

Solución de problemas

Para obtener información sobre errores habituales y cómo solucionarlos, consulta el artículo Solucionar problemas con cargas de trabajo de Arm.

Siguientes pasos