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 la computación de Compute Engine. La serie de máquinas se ha optimizado para ofrecer un alto rendimiento, un coste bajo 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.

Antes de empezar

Antes de empezar, asegúrate de que has 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 CLI de gcloud, obtén la versión más reciente ejecutando el comando gcloud components update. Es posible que las versiones anteriores de la interfaz de línea de comandos de gcloud no admitan la ejecución de los comandos de este documento.
Nota: En las instalaciones de gcloud CLI, 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.

Obtén capacidad para las VMs H4D después de elegir una opción de consumo. Se recomienda asignar recursos densos a las VMs H4D. La asignación de recursos densa está disponible con algunos de los modelos de aprovisionamiento de H4D y te ofrece funciones de gestión de clústeres mejoradas para tu capacidad de H4D. Para obtener capacidad, haz lo siguiente:
1. Consulta los modelos de aprovisionamiento para la creación de VMs y clústeres.
2. Elige una opción de consumo y obtén capacidad.
Asegúrate de que cumples los siguientes requisitos de la versión de GKE:
- 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 Mantenimiento de instancias H4D y Gestionar interrupciones en nodos de GKE que no se migran en tiempo real.

Configurar el clúster y las redes de GKE

Puedes usar Cluster Toolkit para crear rápidamente un clúster de GKE listo para producción que use máquinas virtuales H4D vinculadas a reservas. Las instrucciones de Cluster Toolkit de esta sección usan el blueprint H4D de GKE.

También puedes usar la CLI de Google Cloud para tener la máxima flexibilidad a la hora de configurar tu entorno de clúster con máquinas virtuales asociadas a reservas o de inicio flexible.

Cluster Toolkit

Configurar Cluster Toolkit. Te recomendamos que uses Cloud Shell, ya que las dependencias ya están preinstaladas en Cluster Toolkit.
Obtén la dirección IP del host en el que has instalado Cluster Toolkit:
```
curl ifconfig.me
```
Guarda esta dirección IP para usarla en la variable IP_ADDRESS en un paso posterior.
Crea un segmento de Cloud Storage para almacenar el estado de la implementación de Terraform:
```
gcloud storage buckets create gs://BUCKET_NAME \
    --default-storage-class=STANDARD \
    --project=PROJECT_ID \
    --location=COMPUTE_REGION_TERRAFORM_STATE \
    --uniform-bucket-level-access
gcloud storage buckets update gs://BUCKET_NAME --versioning
```
Sustituye las siguientes variables:
- BUCKET_NAME: el nombre del nuevo segmento de Cloud Storage.
- PROJECT_ID: tu ID de proyecto Google Cloud .
- COMPUTE_REGION_TERRAFORM_STATE: la región de proceso en la que quieres almacenar el estado de la implementación de Terraform.
En el blueprint examples/gke-h4d/gke-h4d-deployment.yaml del repositorio de GitHub, rellena los siguientes ajustes en las secciones terraform_backend_defaults y vars para que coincidan con los valores específicos de tu implementación:
- DEPLOYMENT_NAME: nombre único de la implementación, que debe tener entre 6 y 30 caracteres. Si el nombre de la implementación no es único en un proyecto, se produce un error al crear el clúster. El valor predeterminado es gke-h4d.
- BUCKET_NAME: el nombre del segmento de Cloud Storage que has creado en el paso anterior.
- PROJECT_ID: tu ID de proyecto Google Cloud .
- COMPUTE_REGION: la región de computación del clúster, que debe coincidir con la región en la que las máquinas estén disponibles para tu reserva.
- COMPUTE_ZONE: la zona de computación del grupo de nodos de máquinas H4D. Ten en cuenta que esta zona debe coincidir con la zona en la que las máquinas estén disponibles en tu reserva.
- NODE_COUNT: número de nodos H4D de tu clúster.
- IP_ADDRESS/SUFFIX: el intervalo de direcciones IP al que quiere permitir que se conecte con el clúster. Este bloque CIDR debe incluir la dirección IP de la máquina que quieras usar para llamar a Terraform. Para obtener más información, consulta Cómo funcionan las redes autorizadas.
- En el campo reservation, usa una de las siguientes opciones, en función de si quieres orientar la segmentación a bloques específicos de una reserva al aprovisionar el grupo de nodos:
  - Para colocar el grupo de nodos en cualquier lugar de la reserva, proporciona el nombre de la reserva (RESERVATION_NAME).
  - Para orientar a un bloque específico de tu reserva, usa los nombres de la reserva y del bloque con el siguiente formato:
```
  RESERVATION_NAME/reservationBlocks/BLOCK_NAME
```
    Si no sabes qué bloques están disponibles en tu reserva, consulta Ver la topología de una reserva.
Genera credenciales predeterminadas de la aplicación (ADC) para proporcionar acceso a Terraform. Si usas Cloud Shell, puedes ejecutar el siguiente comando:
```
gcloud auth application-default login
```

Despliega el blueprint para aprovisionar la infraestructura de GKE con los tipos de máquina H4D:

./gcluster deploy -d examples/gke-h4d/gke-h4d-deployment.yaml examples/gke-h4d/gke-h4d.yaml

Cuando se te solicite, selecciona (A)plicar para implementar el plano.
Además, este blueprint aprovisiona una instancia de Filestore y la conecta al clúster de GKE con un volumen persistente (PV). En este blueprint se incluye una plantilla de tarea de ejemplo. Esta plantilla ejecuta un trabajo paralelo que lee y escribe datos en este almacenamiento compartido. Se muestra un kubectl create en las salidas de la implementación que se puede usar para activar el trabajo de ejemplo.

Google Cloud CLI

Sustituye los siguientes valores de los comandos de esta sección:

PROJECT_ID: tu ID de proyecto Google Cloud .
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 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. Si utilizas una reserva, la región y la zona deben coincidir con las de la reserva.
COMPUTE_ZONE: la zona de tu grupo de nodos. Debe ser una zona en la que esté disponible H4D. Si utilizas una reserva, la región y la zona deben coincidir con las de la reserva. No puedes crear un grupo de nodos multizona si quieres que los nodos H4D funcionen con Cloud 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 van a crear 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).

Para crear un clúster con gcloud CLI, sigue estos pasos:

Crea VPCs y subredes: configura la nube privada virtual (VPC) y la subred predeterminadas del clúster. En el caso de la tarjeta de interfaz de red (NIC) IRDMA, crea una VPC y una subred dedicadas. La VPC creada con las siguientes instrucciones usa, según sea necesario, un perfil de red de VPC de Falcon.
1. Crea una VPC para la interfaz de red IRDMA que utilice el protocolo de transporte RDMA sobre Falcon:
```
gcloud compute --project=PROJECT_ID \
  networks create RDMA_NETWORK_PREFIX-net \
  --network-profile=COMPUTE_ZONE-vpc-falcon \
  --subnet-mode=custom
```
2. Crea una subred para la red VPC de Falcon:
```
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 multirred: crea el clúster. Opcionalmente, 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 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 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

Crea un grupo de nodos H4D: crea un grupo de nodos que use H4D y se conecte a la red de VPC Falcon. 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
1. 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, al asegurarse de que los nodos estén ubicados 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
  Sustituye los siguientes valores:
  - POLICY_NAME: el nombre del recurso de política (por ejemplo, h4d-compact).
  - REGION: la región de tu clúster.
2. 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 use nodos H4D aprovisionados con flex-start y que se conecte a la red de VPC de Falcon:
```
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 Docker

Prepara tu imagen con el siguiente ejemplo de Dockerfile:

FROM docker.io/rockylinux/rockylinux:8.10

RUN dnf -y install https://depot.ciq.com/public/download/ciq-sigcloud-next-8/ciq-sigcloud-next-8.x86_64/Packages/c/ciq-sigcloud-next-release-6-1.el8_10.cld_next.noarch.rpm
    && dnf -y update ciq-sigcloud-next-release
    && dnf clean all

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

Para obtener más información sobre las imágenes que admiten IRDMA, consulta las pestañas Interfaces de las tablas de Detalles del sistema operativo.

Configurar los archivos de manifiesto para RDMA

Para habilitar Cloud 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 Cloud RDMA ejecutando rping entre un 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.

Ejecutar cargas de trabajo de computación de alto rendimiento (HPC) con H4D Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.