Preparar el despliegue de una carga de trabajo de Arm en un clúster estándar

En esta página se explica cómo preparar una carga de trabajo para que se programe en nodos Arm de un clúster estándar de GKE. Para obtener más información sobre cómo programar cargas de trabajo de Arm con Autopilot, consulta Implementar cargas de trabajo de Autopilot en la arquitectura Arm.

Para programar correctamente una carga de trabajo en un nodo Arm, debes tener lo siguiente:

Información general

De forma predeterminada, GKE programa las cargas de trabajo solo en nodos basados en x86 (series de máquinas de Compute Engine con procesadores Intel o AMD) colocando un taint (kubernetes.io/arch=arm64:NoSchedule) en todos los nodos Arm. Esta intolerancia evita que las cargas de trabajo compatibles con x86 se programen por error en tus nodos Arm. Si quieres desplegar una carga de trabajo en un nodo Arm, usa los campos que se describen en esta página para indicar al programador que envíe la carga de trabajo al tipo de nodo que quieras.

Usa uno de los siguientes campos:

Cuando usas un selector de nodos o una regla de afinidad de nodos, GKE solo programa tus cargas de trabajo compatibles con Arm cuando has declarado que la imagen de contenedor de la carga de trabajo se puede ejecutar en la arquitectura del nodo.

Si programas una carga de trabajo compatible con Arm con un selector de nodos o con una regla de afinidad de nodos, tal como se describe en las secciones siguientes, GKE añade automáticamente una tolerancia a la configuración de la carga de trabajo para que los pods se puedan ejecutar en los nodos Arm.

Esta tolerancia añadida a la carga de trabajo coincide con la intolerancia (kubernetes.io/arch=arm64:NoSchedule) añadida a todos los nodos Arm para permitir que tu carga de trabajo se programe en nodos Arm.

En algunas situaciones, como cuando tienes imágenes de varias arquitecturas que se pueden ejecutar en cualquier nodo, puede que quieras añadir manualmente esta tolerancia a la configuración de la carga de trabajo. Para obtener instrucciones, consulta Usar tolerancias para programar cargas de trabajo de varias arquitecturas en cualquier arquitectura.

Usar un selector de nodos para programar una carga de trabajo de Arm

Añade el siguiente selector de nodos a la especificación:

nodeSelector:
    kubernetes.io/arch: arm64

El selector de nodos especifica que esta carga de trabajo solo se debe programar en nodos con la etiqueta arm64, que tienen todos los nodos Arm de los clústeres de GKE.

Cuando este selector de nodos se incluye en la configuración de la carga de trabajo, GKE añade la tolerancia para que coincida con la intolerancia y permita que la carga de trabajo se programe en nodos Arm.

Usar una regla de afinidad de nodos para programar una carga de trabajo de Arm

También puedes usar la afinidad de nodos para programar tu carga de trabajo.

Programar una carga de trabajo para una sola arquitectura

Añade la siguiente afinidad de nodo a la especificación:

  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: kubernetes.io/arch
            operator: In
            values:
            - arm64

La regla de afinidad de nodos especifica que la carga de trabajo solo se debe programar en nodos con la etiqueta arm64, que tienen todos los nodos Arm de los clústeres de GKE.

Cuando se incluye esta regla de afinidad de nodos en la configuración de la carga de trabajo, GKE añade la tolerancia para que coincida con la intolerancia y permita que la carga de trabajo se programe en nodos Arm.

Programar cargas de trabajo en arquitecturas x86 y Arm

Si quieres programar una carga de trabajo en arquitecturas x86 (procesadores Intel y AMD) y Arm, puedes especificarlo de diferentes formas.

Usar tolerancias para programar cargas de trabajo de varias arquitecturas en cualquier arquitectura

Si tienes una imagen de varias arquitecturas que quieres programar para cualquier tipo de arquitectura disponible en un clúster estándar, solo tienes que añadir la tolerancia a la especificación de la carga de trabajo. No necesitas el selector de nodos ni las reglas de afinidad de nodos que se describen en esta página, ya que la carga de trabajo se puede programar para todos los tipos de arquitectura.

Añade la tolerancia:

  tolerations:
    - key: kubernetes.io/arch
      operator: Equal
      value: arm64
      effect: NoSchedule

Con esta tolerancia, GKE podría programar una carga de trabajo en nodos con cualquier tipo de arquitectura.

Por ejemplo, si tienes un clúster con los siguientes grupos de nodos:

  • my-c4a-node-pool, con máquinas virtuales c4a-standard-16 (arm64).
  • my-c2-node-pool, con máquinas virtuales c2-standard-8 (amd64).
  • my-t2d-node-pool, con máquinas virtuales t2-standard-48 (amd64).

Si implementas en este clúster una carga de trabajo que usa una imagen de varias arquitecturas y la tolerancia arm64 en la configuración de la carga de trabajo, GKE puede programar la carga de trabajo en todos los grupos de nodos.

Usar la regla de afinidad de nodos para programar cargas de trabajo de varias arquitecturas en cualquier arquitectura

Si quieres que una carga de trabajo se programe en nodos de diferentes tipos de arquitectura, como x86 y Arm, también puedes usar una regla de afinidad de nodos. Con las reglas de afinidad de nodos, puedes especificar exactamente en qué tipos de arquitectura quieres programar la carga de trabajo. Este método se recomienda para programar cargas de trabajo en clústeres de Autopilot. Para obtener más información, consulta Desplegar cargas de trabajo de Autopilot en la arquitectura Arm.

En el caso de las cargas de trabajo basadas en x86, no necesitas estos selectores de nodos, reglas de afinidad de nodos ni tolerancias para programar la carga de trabajo. Si tienes una imagen que solo quieres programar en nodos basados en x86, no tienes que usar estos campos.

Para programar cargas de trabajo en cualquier tipo de arquitectura, incluye arm64 y amd64 en la sección values del campo de afinidad de nodo. amd64 incluye cualquier nodo que utilice procesadores x86.

En el siguiente ejemplo se especifica que esta carga de trabajo se puede programar en nodos con procesadores Arm o x86:

  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: kubernetes.io/arch
            operator: In
            values:
            - arm64
            - amd64

Las etiquetas de cada tipo de arquitectura son las siguientes:

Por ejemplo, si tienes un clúster con los siguientes grupos de nodos y la regla de afinidad de nodos indicada:

  • my-c4a-node-pool, con máquinas virtuales c4a-standard-16 (arm64).
  • my-c2-node-pool, con máquinas virtuales c2-standard-8 (amd64).
  • my-t2d-node-pool, con máquinas virtuales t2-standard-48 (amd64).

Si implementas en este clúster una carga de trabajo que usa una imagen de varias arquitecturas y la afinidad de nodo con arm64 incluida en la lista values, GKE añade la tolerancia en la configuración de la carga de trabajo y puede programar la carga de trabajo en todos los grupos de nodos.

Desplegar la carga de trabajo

Ahora que has especificado dónde se deben programar tus cargas de trabajo compatibles con Arm, puedes desplegarlas.

Cuando despliega una carga de trabajo en un clúster de GKE, las instrucciones son las mismas en todos los tipos de arquitectura. Puedes implementar una carga de trabajo compatible con Arm como cualquier otra carga de trabajo, siempre que hayas completado los pasos previos. Para ver ejemplos de despliegue de cargas de trabajo, consulta las siguientes páginas:

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