Prepara una carga de trabajo de Arm para la implementación

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

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

Descripció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) mediante la colocación de un taint (kubernetes.io/arch=arm64:NoSchedule) en todos los nodos Arm. Este taint evita que las cargas de trabajo compatibles con x86 se programen de forma involuntaria en los nodos Arm. Si quieres implementar una carga de trabajo en un nodo Arm, usa los campos descritos en esta página para guiar al programador a fin de que envíe la carga de trabajo al tipo de nodo deseado.

Usa uno de los siguientes campos:

Cuando usas un selector de nodos o una regla de afinidad de nodo, GKE solo programará tus cargas de trabajo compatibles con Arm cuando hayas declarado que la imagen de contenedor de la carga de trabajo puede ejecutarse 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 nodo como se describe en las siguientes secciones, GKE agrega automáticamente una tolerancia en la configuración de la carga de trabajo para que los pods puedan ejecutarse en los nodos Arm.

Esta tolerancia agregada a la carga de trabajo coincide con el taint (kubernetes.io/arch=arm64:NoSchedule) agregado 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 pueden ejecutarse en cualquier nodo, es posible que desees agregar esta tolerancia de forma manual a la configuración de la carga de trabajo. Si deseas obtener instrucciones, consulta Usa la tolerancia para programar cargas de trabajo multiarquitectura en cualquier arquitectura.

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

Agrega 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 debe programarse en los nodos con la etiqueta arm64, que tienen todos los nodos Arm en clústeres de GKE.

Cuando este selector de nodos se incluye en la configuración de la carga de trabajo, GKE agrega la tolerancia para que coincida con el taint a fin de permitir que la carga de trabajo se programe en nodos Arm.

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

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

Programa la carga de trabajo en una sola arquitectura

Agrega la siguiente afinidad de nodos 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 debe programarse en nodos con la etiqueta arm64, que tienen todos los nodos Arm en clústeres de GKE.

Cuando esta regla de afinidad de nodo se incluye en la configuración de la carga de trabajo, GKE agrega la tolerancia para que coincida con el taint a fin de permitir que la carga de trabajo se programe en nodos Arm.

Programa la carga de trabajo en las arquitecturas x86 y Arm

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

Usa la tolerancia para programar cargas de trabajo multiarquitectura en cualquier arquitectura

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

Agrega 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-t2a-node-pool, using t2a-standard-16 VMs (arm64).
  • my-c2-node-pool, using c2-standard-8 VMs (amd64).
  • my-t2d-node-pool, using t2-standard-48 VMs (amd64).

Si implementas en este clúster una carga de trabajo que usa una imagen multiarquitectura 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.

Usa 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 distintos tipos de arquitectura, incluidos x86 y Arm, también puedes usar una regla de afinidad de nodos. Con las reglas de afinidad de nodos, puedes especificar con exactitud qué tipos de arquitectura deseas programar en la carga de trabajo. Este enfoque se recomienda para programar cargas de trabajo en clústeres de Autopilot. Para obtener más información, consulta Implementa cargas de trabajo de Autopilot en la arquitectura Arm.

Con las cargas de trabajo basadas en x86, no necesitas estos selectores de nodos, reglas de afinidad de nodos ni tolerancias para que se programe la carga de trabajo. Si tienes una imagen que solo deseas programar en nodos basados en x86, no necesitas usar estos campos.

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

En el siguiente ejemplo, se especifica que esta carga de trabajo podría programarse en nodos con procesadores Arm o procesadores x86:

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

Las etiquetas para 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 determinada, haz lo siguiente:

  • my-t2a-node-pool, using t2a-standard-16 VMs (arm64).
  • my-c2-node-pool, using c2-standard-8 VMs (amd64).
  • my-t2d-node-pool, using t2-standard-48 VMs (amd64).

Si implementas en este clúster una carga de trabajo que usa una imagen multiarquitectura y la afinidad de nodos con arm64 incluida en la lista values, GKE agrega la tolerancia en la configuración de la carga de trabajo y podría programar la carga de trabajo en todos los grupos de nodos.

Implementa la carga de trabajo

Ahora que especificaste dónde se deben programar tus cargas de trabajo compatibles con Arm, puedes implementar tu carga de trabajo.

Cuando implementas 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 lo harías con cualquier otra carga de trabajo, siempre que hayas completado los pasos de los requisitos previos. Para ver ejemplos de implementación de cargas de trabajo, consulta las siguientes páginas:

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?