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 procesamiento 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 nodos.

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 deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos que se describen en este documento.
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.

Obtén capacidad para las VMs H4D después de elegir una opción de consumo. Se recomienda la asignación densa de recursos para las VMs H4D. La asignación de recursos densa está disponible con algunos de los modelos de aprovisionamiento para H4D y te proporciona capacidades mejoradas de administración de clústeres para tu capacidad de H4D. Para obtener capacidad, haz lo siguiente:
1. Revisa los modelos de aprovisionamiento para la creación de VM y clústeres.
2. Elige una opción de consumo y obtén capacidad.
Asegúrate de cumplir con los siguientes requisitos de versión de GKE:
- 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 flex-start
  - 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 y Administra las interrupciones en los nodos de GKE que no migran en vivo.

Configura el clúster y las redes de GKE

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

Como alternativa, puedes usar Google Cloud CLI para obtener la máxima flexibilidad en la configuración de tu entorno de clúster con VMs vinculadas a reservas o de inicio flexible.

Cluster Toolkit

Configura Cluster Toolkit. Te recomendamos que uses Cloud Shell, ya que las dependencias ya están preinstaladas para Cluster Toolkit.
Obtén la dirección IP de la máquina anfitrión en la que instalaste Cluster Toolkit:
```
curl ifconfig.me
```
Guarda esta dirección IP para usarla en la variable IP_ADDRESS en un paso posterior.
Crea un bucket 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
```
Reemplaza las siguientes variables:
- BUCKET_NAME: Es el nombre del nuevo bucket de Cloud Storage.
- PROJECT_ID: El ID de tu proyecto Google Cloud .
- COMPUTE_REGION_TERRAFORM_STATE: Es la región de procesamiento en la que deseas almacenar el estado de la implementación de Terraform.
En el blueprint de examples/gke-h4d/gke-h4d-deployment.yaml del repositorio de GitHub, completa los siguientes parámetros de configuración en las secciones terraform_backend_defaults y vars para que coincidan con los valores específicos de tu implementación:
- DEPLOYMENT_NAME: Es un nombre único para la implementación, que debe tener entre 6 y 30 caracteres. Si el nombre de la implementación no es único dentro de un proyecto, falla la creación del clúster. El valor predeterminado es gke-h4d.
- BUCKET_NAME: Es el nombre del bucket de Cloud Storage que creaste en el paso anterior.
- PROJECT_ID: El ID de tu proyecto Google Cloud .
- COMPUTE_REGION: Es la región de procesamiento del clúster, que debe coincidir con la región en la que hay máquinas disponibles para tu reserva.
- COMPUTE_ZONE: Es la zona de procesamiento 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: Es la cantidad de nodos H4D en tu clúster.
- IP_ADDRESS/SUFFIX: Es el rango de direcciones IP que deseas permitir que se conecten con el clúster. Este bloque CIDR debe incluir la dirección IP de la máquina que deseas usar para llamar a Terraform. Para obtener más información, consulta Cómo funcionan las redes autorizadas.
- Para el campo reservation, usa una de las siguientes opciones, según si deseas segmentar bloques específicos en una reserva cuando aprovisiones el grupo de nodos:
  - Para colocar el grupo de nodos en cualquier lugar de la reserva, proporciona el nombre de tu reserva (RESERVATION_NAME).
  - Para segmentar un bloque específico dentro 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 Cómo 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
```
Implementa el blueprint para aprovisionar la infraestructura de GKE con los tipos de máquinas 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 blueprint.
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 Job de ejemplo. Esta plantilla ejecuta un trabajo paralelo que lee y escribe datos en este almacenamiento compartido. En los resultados de la implementación, se muestra un kubectl create que se puede usar para activar el trabajo de muestra.

Google Cloud CLI

Reemplaza los siguientes valores para los comandos de esta sección:

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

Sigue estos pasos para crear un clúster con gcloud CLI:

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 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 de IRDMA que use el protocolo de transporte de RDMA a través de 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 de 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 redes múltiples: Crea el clúster. 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 comando siguiente:
```
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 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 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 de Falcon. Puedes usar nodos de H4D vinculados a la reserva y colocació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
1. Crea una política de recursos para la posición compacta. La colocación compacta optimiza el rendimiento para las cargas de trabajo de HPC estrechamente vinculadas, que se ejecutan en varios nodos, ya que garantiza que los nodos estén ubicados físicamente unos cerca de otros dentro de una zona.
  
  Ejecuta el comando siguiente:
  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.
2. 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 inicio flexible 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
```
Reemplaza MAX_NODES por la cantidad máxima de nodos a los 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 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 qué imágenes admiten IRDMA, consulta las pestañas Interfaces en las tablas de Detalles del sistema operativo.

Cómo configurar tus manifiestos para RDMA

Para habilitar Cloud RDMA, agrega 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"},
      ]

Cómo probar RDMA con rping

Para verificar la funcionalidad de Cloud 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.

Ejecuta cargas de trabajo de computación de alto rendimiento (HPC) con H4D Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.