Prepárate para implementar una carga de trabajo de Arm en un clúster de Standard

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 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. De manera opcional, puedes quitar este taint predeterminado si deseas que las cargas de trabajo compatibles con x86 se programen en nodos Arm sin necesidad de la tolerancia correspondiente. Para obtener más información, consulta Configura el taint predeterminado de la arquitectura Arm.

Si quieres implementar una carga de trabajo en un nodo Arm que tiene el taint predeterminado, usa los campos que se describen en este documento para guiar al programador para que envíe la carga de trabajo al tipo de nodo solicitado.

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, de forma predeterminada, 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, te recomendamos que agregues esta tolerancia de forma manual a la configuración de la carga de trabajo. Para 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 arquitecturas x86 y Arm

Si deseas programar una carga de trabajo en arquitecturas x86 (procesadores Intel y AMD) y Arm, y tus grupos de nodos Arm usan el comportamiento predeterminado de taint, puedes especificarlo de diferentes maneras. En las siguientes instrucciones, se supone que tus grupos de nodos Arm usan el taint predeterminado.

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

Si tienes una imagen multiarquitectura que deseas programar en un tipo de arquitectura disponible en un clúster estándar, solo debes 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 que se describen 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-c4a-node-pool, using c4a-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. Se recomienda este enfoque 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 de 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 todos los nodos que usan 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-c4a-node-pool, using c4a-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.

Configura el taint predeterminado de la arquitectura Arm

De forma predeterminada, GKE aplica taint a todos los nodos Arm con el taint kubernetes.io/arch=arm64:NoSchedule. Este taint evita que las cargas de trabajo compatibles solo con la arquitectura x86, pero no con la arquitectura Arm, se programen en nodos Arm. Si tienes cargas de trabajo que son compatibles con x86 y Arm, puedes inhabilitar este taint para permitir que GKE programe estas cargas de trabajo en nodos Arm sin necesidad de una tolerancia correspondiente al taint.

Puedes actualizar el comportamiento predeterminado solo en grupos de nodos Standard en clústeres de GKE en los que el plano de control ejecuta la versión 1.35.0-gke.2141000 o posterior, o con nodos creados para ComputeClasses personalizados. Para obtener más información, consulta Configura el taint predeterminado de la arquitectura Arm. La actualización del comportamiento de taint no se aplica a la implementación de cargas de trabajo de Arm con Autopilot. Para obtener más información, consulta Implementa cargas de trabajo de Autopilot en la arquitectura de Arm.

Puedes configurar este comportamiento en las siguientes situaciones con grupos de nodos Standard:

  • Durante la creación del clúster, para el grupo de nodos Standard predeterminado
  • Cuando creas o actualizas un grupo de nodos Standard

Si tienes cargas de trabajo que se ejecutan en el clúster que no son compatibles con Arm, no quites el taint predeterminado, ya que las cargas de trabajo incompatibles podrían programarse en los nodos Arm sin taint.

Para configurar el taint de nodo predeterminado para nodos Arm, selecciona una de las siguientes opciones:

Gcloud CLI

Para establecer el comportamiento de taint con gcloud CLI, usa la marca --node-architecture-taint-behavior cuando realices cualquiera de las siguientes operaciones:

  • Crea un clúster Standard con un comportamiento de taint específico para el grupo de nodos predeterminado con el gcloud container cluster create comando:

    gcloud container cluster create CLUSTER_NAME
    --location=CONTROL_PLANE_LOCATION \
    --node-architecture-taint-behavior=BEHAVIOR

  • Crea un grupo de nodos Standard con el gcloud container node-pools create comando:

    gcloud container node-pools create POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --node-architecture-taint-behavior=BEHAVIOR

  • Actualiza un grupo de nodos Standard con el gcloud container node-pools update comando:

    gcloud container node-pools update POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --node-architecture-taint-behavior=BEHAVIOR

Para estos comandos, reemplaza lo siguiente:

  • CLUSTER_NAME: El nombre de tu clúster.
  • CONTROL_PLANE_LOCATION: La ubicación de Compute Engine del plano de control de tu clúster. Proporciona una región para los clústeres regionales o una zona para los clústeres zonales.
  • POOL_NAME: El nombre de tu grupo de nodos.

  • BEHAVIOR: Una de las siguientes configuraciones:

    • none: GKE omite el taint predeterminado de kubernetes.io/arch=arm64:NoSchedule.
    • arm: Establece de forma explícita el comportamiento predeterminado, que agrega los taints kubernetes.io/arch=arm64:NoSchedule para todos los nodos en el grupo de nodos Arm.

Cuando modificas el comportamiento de taint de la arquitectura de nodos para un grupo de nodos Standard, GKE actualiza de inmediato los taints sin necesidad de volver a crear los nodos.

Terraform

Agrega el siguiente bloque taint_config en node_config para configurar el comportamiento de taint de la arquitectura:

taint_config {
  architecture_taint_behavior = "BEHAVIOR"
}

Reemplaza BEHAVIOR por una de las siguientes configuraciones:

  • NONE: GKE omite el taint predeterminado de kubernetes.io/arch=arm64:NoSchedule.
  • ARM: Establece de forma explícita el comportamiento predeterminado, que agrega los taints kubernetes.io/arch=arm64:NoSchedule para todos los nodos del grupo de nodos Arm.

Un node_config completo para un grupo de nodos Standard que incluye este bloque se ve de la siguiente manera:

resource "google_container_node_pool" "primary_preemptible_nodes" {
  name       = "NODE_POOL_NAME"
  location   = "NODE_POOL_LOCATION"
  cluster    = google_container_cluster.primary.name
  node_count = 1

  node_config {
    preemptible  = true
    machine_type = "ARM_MACHINE_TYPE"

    # Google recommends custom service accounts that have cloud-platform scope and permissions granted via IAM Roles.
    service_account = google_service_account.default.email
    oauth_scopes    = [
      "https://www.googleapis.com/auth/cloud-platform"
    ]
    taint_config {
      architecture_taint_behavior = "BEHAVIOR"
    }
  }
}

En este ejemplo, NODE_POOL_NAME representa el nombre del grupo de nodos y NODE_POOL_LOCATION representa la ubicación del plano de control del clúster.

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?