Esta página se ha traducido con Cloud Translation API.

Ejecutar cargas de trabajo de computación de alto rendimiento (HPC) con H4D

Estándar

En este documento se explica cómo ejecutar cargas de trabajo de computación de alto rendimiento (HPC) en clústeres de Google Kubernetes Engine (GKE) que usan la serie de máquinas H4D y el acceso directo a memoria remoto (RDMA).

H4D es una serie de máquinas de la familia de máquinas optimizadas para HPC de Compute Engine. La serie de máquinas se ha optimizado para ofrecer un alto rendimiento, un bajo coste y escalabilidad. H4D funciona bien en aplicaciones que se escalan en varios nodos. Las instancias H4D configuradas para usar RDMA admiten un ancho de banda de red de hasta 200 Gbps entre nodos.

Las instrucciones de esta página usan la CLI de Google Cloud y te ofrecen la máxima flexibilidad para configurar el entorno de tu clúster. También puedes usar Cluster Toolkit para crear rápidamente un clúster de GKE listo para producción que use H4D. Para obtener más información, consulta el blueprint de H4D de GKE.

Antes de empezar

Antes de empezar, asegúrate de haber 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 gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.
Nota: Si ya tienes instalada la CLI de gcloud, asegúrate de definir la compute/region propiedad. Si usas principalmente clústeres zonales, define compute/zone en su lugar. Si defines 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 tengas que especificar la ubicación en determinados comandos si la ubicación de tu clúster es diferente de la predeterminada que hayas definido.

Usa el modo de aprovisionamiento de inicio flexible para obtener VMs H4D. Si necesitas recursos durante más de 90 días o más de 256 VMs H4D en una solicitud, ponte en contacto con el equipo de tu cuenta. También puedes aprovisionar máquinas virtuales H4D bajo demanda, en función de la capacidad disponible en tu región.
Usa la versión 1.32.6-gke.1060000 de GKE o una posterior para crear un grupo de nodos con VMs H4D reservadas en el modo Estándar de GKE.
Usa la versión 1.33.2-gke.4731000 de GKE o una posterior para crear lo siguiente:
- Nodos H4D con flex-start
- Nodos H4D con Autopilot
- Nodos H4D con autoescalado de clústeres en clústeres estándar
- Nodos H4D con aprovisionamiento automático de nodos en clústeres estándar
Usa solo las ubicaciones en las que esté disponible el tipo de máquina H4D. Para obtener más información, consulta la tabla de regiones y zonas disponibles y filtra por H4D.
Usa solo imágenes de nodo de Container-Optimized OS.
Consulta las limitaciones de H4D.
Consulta cómo gestionar el mantenimiento del host, ya que los tipos de máquina H4D no admiten la migración en tiempo real. Para obtener más información, consulta Experiencia de mantenimiento de instancias H4D.
Sustituye los siguientes valores de los comandos de las secciones siguientes:
- PROJECT_ID: tu Google Cloud ID de proyecto.
- 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. Los clústeres regionales se recomiendan para cargas de trabajo de producción. En el caso de los clústeres regionales, la región debe incluir una zona en la que esté disponible H4D. En el caso de los clústeres zonales, la zona debe tener disponibilidad de H4D.
- COMPUTE_ZONE: la zona de tu grupo de nodos. Debe ser una zona en la que esté disponible H4D. No puedes crear un grupo de nodos multizona si quieres que los nodos H4D funcionen con RDMA.
- RDMA_NETWORK_PREFIX: el prefijo de red RDMA (por ejemplo, h4d-rdma).
- RDMA_SUBNET_CIDR: el intervalo CIDR de la subred RDMA. Asegúrate de que este intervalo no se solape con las redes predeterminadas del clúster.
- NODE_POOL_NAME: el nombre de tu grupo de nodos H4D.
- NODE_COUNT: el número de nodos H4D que se crearán en el grupo de nodos.
- H4D_MACHINE_TYPE: el tipo de máquina H4D que se va a usar (por ejemplo, h4d-highmem-192-lssd).

Crear VPCs y subredes

Configura la nube privada virtual (VPC) y la subred predeterminadas del clúster. Para la tarjeta de interfaz de red (NIC) RDMA, crea una VPC y una subred dedicadas. La VPC creada con las siguientes instrucciones usa, según sea necesario, un perfil de red RDMA.

Crea una VPC de HPC para las NICs RDMA:

gcloud compute --project=PROJECT_ID \
  networks create RDMA_NETWORK_PREFIX-net \
  --network-profile=COMPUTE_ZONE-vpc-falcon \
  --subnet-mode=custom

Crea una subred para la red RDMA:

gcloud compute --project=PROJECT_ID \
  networks subnets create \
  RDMA_NETWORK_PREFIX-sub-0 \
  --network=RDMA_NETWORK_PREFIX-net \
  --region=CONTROL_PLANE_LOCATION \
  --range=RDMA_SUBNET_CIDR

Crear un clúster de GKE con multirred

Crea el clúster de GKE con la función de multirred habilitada. Si quieres, con este comando puedes proporcionar explícitamente los intervalos CIDR secundarios para servicios y pods.

Ejecuta el siguiente comando:

gcloud container clusters create CLUSTER_NAME --project PROJECT_ID \
  --enable-dataplane-v2 --enable-ip-alias --location=CONTROL_PLANE_LOCATION \
  --enable-multi-networking \
  [--services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR]

Si usas estas marcas opcionales, sustituye los siguientes valores adicionales:

SERVICE_CIDR: el intervalo CIDR secundario de los servicios.
POD_CIDR: el intervalo CIDR secundario de los pods.

Cuando uses estas marcas, comprueba que los intervalos CIDR no se solapen con los intervalos de subredes de las redes de nodos adicionales. Por ejemplo, SERVICE_CIDR=10.65.0.0/19 y POD_CIDR=10.64.0.0/19.

Crear objetos de red de GKE

Configura la red de VPC mediante conjuntos de parámetros de red de GKE. Aplica los objetos GKENetworkParamSet y Network:

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
EOF

Crear un grupo de nodos H4D

Crea un grupo de nodos que use H4D y se conecte a la red RDMA. Puedes usar nodos H4D vinculados a reservas y colocación compacta. También puedes usar nodos H4D aprovisionados con flex-start. Selecciona la pestaña que corresponda a tu opción de consumo:

Con reserva

Crea una política de recursos para la colocación compacta. La colocación compacta optimiza el rendimiento de las cargas de trabajo de HPC estrechamente acopladas, que se ejecutan en varios nodos, asegurándose de que los nodos estén ubicados físicamente entre sí en una zona.

Ejecuta el siguiente comando:
```
gcloud compute resource-policies create group-placement POLICY_NAME \
    --region REGION --collocation collocated
```
Sustituye los siguientes valores:
- POLICY_NAME: el nombre de la política de recursos (por ejemplo, h4d-compact).
- REGION: la región de tu clúster.

Crea un grupo de nodos que use H4D y se conecte a la red RDMA:

gcloud container node-pools create NODE_POOL_NAME --project PROJECT_ID \
  --location=CONTROL_PLANE_LOCATION --cluster CLUSTER_NAME --num-nodes=NODE_COUNT \
  --node-locations=COMPUTE_ZONE \
  --machine-type H4D_MACHINE_TYPE \
  --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-0 \
  --placement-policy POLICY_NAME \
  --max-surge-upgrade 0  \
  --max-unavailable-upgrade MAX_UNAVAILABLE

Sustituye MAX_UNAVAILABLE por el número máximo de nodos que pueden no estar disponibles al mismo tiempo durante una actualización del grupo de nodos. Para una colocación compacta, recomendamos actualizaciones rápidas sin picos para optimizar la probabilidad de encontrar nodos colocados durante las actualizaciones.

Inicio flexible

Crea un grupo de nodos que utilice nodos H4D aprovisionados con flex-start y que se conecte a la red RDMA:

gcloud container node-pools create NODE_POOL_NAME --project PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION --cluster CLUSTER_NAME \
    --node-locations=COMPUTE_ZONE \
    --machine-type H4D_MACHINE_TYPE \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-0 \
    --flex-start --enable-autoscaling --reservation-affinity=none \
    --min-nodes=0 --max-nodes=MAX_NODES --num-nodes=0

Sustituye MAX_NODES por el número máximo de nodos al que se escalará automáticamente el grupo de nodos especificado por zona.

Preparar la imagen de Docker

Prepara tu imagen con el siguiente ejemplo de Dockerfile:

FROM rockylinux:8.9

RUN dnf install https://depot.ciq.com/public/files/gce-accelerator/irdma-kernel-modules-el8-x86_64/irdma-repos.rpm -y

RUN dnf install rdma-core libibverbs-utils librdmacm-utils infiniband-diags perftest -y

Práctica recomendada:

Rocky 8 es la imagen basada en contenedores recomendada que admite RDMA. Es posible que el controlador iRDMA aún no esté disponible en otras distribuciones de Linux.

Configurar los archivos de manifiesto para RDMA

Para habilitar RDMA, añade las siguientes anotaciones a los metadatos de tu pod:

metadata:
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"rdma-0"},
      ]

Probar RDMA con rping

Verifica la funcionalidad de RDMA ejecutando rping entre un pod de servidor y un pod de cliente:

En el pod del servidor, ejecuta el comando rping:
```
rping -s
```

En el pod del cliente, ejecuta el comando rping:

rping -c -C 2 -d -a SERVER_IP

Sustituye SERVER_IP por la dirección IP del pod del servidor.

Si la operación se realiza correctamente, el resultado será similar al siguiente:

created cm_id 0x5b597bf94800
cma_event type RDMA_CM_EVENT_ADDR_RESOLVED cma_id 0x5b597bf94800 (parent)
cma_event type RDMA_CM_EVENT_ROUTE_RESOLVED cma_id 0x5b597bf94800 (parent)
rdma_resolve_addr - rdma_resolve_route successful
created pd 0x5b597bf94fa0
created channel 0x5b597bf96830
created cq 0x5b597bf94ff0
created qp 0x5b597bf96c00
rping_setup_buffers called on cb 0x5b597bf8c820
allocated & registered buffers...
cq_thread started.
cma_event type RDMA_CM_EVENT_ESTABLISHED cma_id 0x5b597bf94800 (parent)
ESTABLISHED
rdma_connect successful
RDMA addr 5b597bf8cd80 rkey dadac8c4 len 64
send completion
recv completion
RDMA addr 5b597bf8cff0 rkey 86ef015f len 64
send completion
recv completion
RDMA addr 5b597bf8cd80 rkey dadac8c4 len 64
send completion
recv completion
RDMA addr 5b597bf8cff0 rkey 86ef015f len 64
send completion
recv completion
rping_free_buffers called on cb 0x5b597bf8c820
destroy cm_id 0x5b597bf94800

Siguientes pasos

Consulta más información sobre la computación de alto rendimiento.
Algunas cargas de trabajo de HPC requieren una interfaz de transferencia de mensajes (MPI) para ejecutar cargas de trabajo multinodo estrechamente acopladas con RDMA. Para obtener más información sobre cómo configurar MPI en tu clúster para los nodos H4D, consulta Ejecutar cargas de trabajo de MPI en GKE H4D.