Se usó la API de Cloud Translation para traducir esta página.

Ejecuta 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 procesamiento 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 está optimizada para ofrecer un alto rendimiento, un bajo costo y escalabilidad. H4D funciona bien para las aplicaciones que escalan en varios nodos. Las instancias H4D configuradas para usar RDMA admiten un ancho de banda de red de hasta 200 Gbps entre los nodos.

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

Antes de comenzar

Antes de comenzar, 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, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar la propiedad compute/region. Si usas principalmente clústeres zonales, configura compute/zone en su lugar. Cuando configuras 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 debas especificar la ubicación en ciertos comandos si la ubicación de tu clúster difiere de la predeterminada que estableciste.

Usa el modo de aprovisionamiento de inicio flexible para obtener VMs de H4D. Si necesitas recursos por más de 90 días o más de 256 VMs H4D en una solicitud, comunícate con tu equipo de cuentas. También puedes aprovisionar VMs H4D a pedido, según la capacidad disponible en tu región.
Usa la versión 1.32.6-gke.1060000 o posterior de GKE 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 inicio flexible
- Nodos H4D con Autopilot
- Nodos H4D con ajuste de escala automático del clúster en clústeres de Standard
- Nodos H4D con aprovisionamiento automático de nodos en clústeres de Standard
Usa solo ubicaciones en las que esté disponible el tipo de máquina H4D. Para obtener más información, consulta la tabla en Regiones y zonas disponibles, y filtra por H4D.
Usa solo imágenes de nodos de Container-Optimized OS.
Revisa las limitaciones de H4D.
Revisa cómo controlar el mantenimiento del host, ya que los tipos de máquinas H4D no admiten la migración en vivo. Para obtener más información, consulta Experiencia de mantenimiento para instancias H4D.
Reemplaza los siguientes valores para los comandos de las próximas secciones:
- PROJECT_ID: Es el ID de tu proyecto deGoogle Cloud .
- CLUSTER_NAME: Es el nombre de tu clúster.
- CONTROL_PLANE_LOCATION: Es 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. Se recomiendan los clústeres regionales para las 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: Es la zona de tu grupo de nodos. Debe ser una zona en la que esté disponible el H4D. No puedes crear un grupo de nodos multizona si quieres que los nodos H4D funcionen con RDMA.
- RDMA_NETWORK_PREFIX: Es el prefijo de la red RDMA (por ejemplo, h4d-rdma).
- RDMA_SUBNET_CIDR: Es el rango de CIDR de la subred de RDMA. Asegúrate de que este rango no se superponga con las redes predeterminadas del clúster.
- NODE_POOL_NAME: el nombre de tu grupo de nodos H4D
- NODE_COUNT: Es la cantidad de nodos H4D que se crearán en el grupo de nodos.
- H4D_MACHINE_TYPE: el tipo de máquina H4D que se usará (por ejemplo, h4d-highmem-192-lssd)

Crea VPC y subredes

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

Crea una VPC de HPC para las NIC de 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 de 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

Crea un clúster de GKE con varias redes

Crea el clúster de GKE con varias redes habilitadas. De manera opcional, con este comando, puedes proporcionar de forma explícita los rangos de CIDR secundarios para los servicios y los 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, reemplaza los siguientes valores adicionales:

SERVICE_CIDR: Es el rango de CIDR secundario para los servicios.
POD_CIDR: Es el rango de CIDR secundario para los Pods.

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

Crea objetos de red de GKE

Configura la red de VPC con los 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

Crea un grupo de nodos H4D

Crea un grupo de nodos que use H4D y se conecte a la red de RDMA. Puedes usar nodos de H4D vinculados a la reserva y ubicación compacta. También puedes usar nodos H4D aprovisionados con inicio flexible. Selecciona la pestaña que corresponda a tu opción de consumo:

Con reserva

Crea una política de recursos para la posición compacta. La posición compacta optimiza el rendimiento de las cargas de trabajo de HPC vinculadas de forma estrecha (que se ejecutan en varios nodos) garantizando que los nodos se ubiquen físicamente unos cerca de otros dentro de una zona.

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

Crea un grupo de nodos que use H4D y se conecte a la red de 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

Reemplaza MAX_UNAVAILABLE por la cantidad máxima de nodos que pueden no estar disponibles al mismo tiempo durante una actualización del grupo de nodos. En el caso de las posiciones compactas, recomendamos actualizaciones rápidas que no sean de aumento para optimizar la probabilidad de encontrar nodos ubicados durante las actualizaciones.

Inicio flexible

Crea un grupo de nodos que use 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

Reemplaza MAX_NODES por la cantidad máxima de nodos a la que se ajustará la escala automáticamente para el grupo de nodos especificado por zona.

Prepara tu imagen de Docker

Prepara tu imagen con el siguiente Dockerfile de ejemplo:

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 de forma generalizada en otras distribuciones de Linux.

Cómo configurar tus manifiestos para RDMA

Para habilitar RDMA, agrega las siguientes anotaciones a los metadatos del Pod:

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

Cómo probar RDMA con rping

Para verificar la funcionalidad de RDMA, ejecuta 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

Reemplaza SERVER_IP por la dirección IP del Pod del servidor.

Si la operación se realiza de forma correcta, el resultado es 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

¿Qué sigue?

Obtén más información sobre la computación de alto rendimiento.
Algunas cargas de trabajo de HPC requieren una interfaz de transmisión de mensajes (MPI) para ejecutar cargas de trabajo de varios nodos con acoplamiento alto con RDMA. Para obtener más información sobre cómo configurar MPI en tu clúster para tus nodos H4D, consulta Ejecuta cargas de trabajo de MPI en H4D de GKE.