Cette page a été traduite par l'API Cloud Translation.

Exécuter des charges de travail de calcul hautes performances (HPC) avec H4D

Standard

Ce document explique comment exécuter des charges de travail de calcul haute performance (HPC) sur des clusters Google Kubernetes Engine (GKE) qui utilisent la série de machines H4D et l'accès direct à la mémoire à distance (RDMA).

H4D est une série de machines de la famille de machines optimisées pour le HPC pour Compute Engine. Cette série de machines est optimisée pour offrir des performances élevées, un faible coût et une grande évolutivité. H4D fonctionne bien pour les applications qui évoluent sur plusieurs nœuds. Les instances H4D configurées pour utiliser RDMA sont compatibles avec une bande passante réseau pouvant atteindre 200 Gbit/s entre les nœuds.

Les instructions de cette page utilisent Google Cloud CLI et vous offrent une flexibilité maximale pour configurer l'environnement de votre cluster. Vous pouvez également utiliser Cluster Toolkit pour créer rapidement un cluster GKE prêt pour la production qui utilise H4D. Pour en savoir plus, consultez le blueprint GKE H4D.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir la propriété compute/region. Si vous utilisez principalement des clusters zonaux, définissez plutôt compute/zone. En définissant un emplacement par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location. Vous devrez peut-être spécifier l'emplacement dans certaines commandes si l'emplacement de votre cluster diffère de celui par défaut que vous avez défini.

Utilisez le mode de provisionnement de démarrage flexible pour obtenir des VM H4D. Si vous avez besoin de ressources pour plus de 90 jours ou de plus de 256 VM H4D dans une requête, contactez l'équipe chargée de votre compte. Vous pouvez également provisionner des VM H4D à la demande, en fonction de la capacité disponible dans votre région.
Utilisez GKE version 1.32.6-gke.1060000 ou ultérieure pour créer un pool de nœuds avec des VM H4D réservées en mode GKE Standard.
Utilisez GKE version 1.33.2-gke.4731000 ou ultérieure pour créer les éléments suivants :
- Nœuds H4D avec démarrage flexible
- Nœuds H4D avec Autopilot
- Nœuds H4D avec autoscaling de cluster dans les clusters Standard
- Nœuds H4D avec provisionnement automatique des nœuds dans les clusters Standard
N'utilisez que les régions où le type de machine H4D est disponible. Pour en savoir plus, consultez le tableau de la section Régions et zones disponibles, en filtrant sur H4D.
Utilisez uniquement les images de nœud Container-Optimized OS.
Consultez les limites de H4D.
Découvrez comment gérer la maintenance de l'hôte, car les types de machines H4D ne sont pas compatibles avec la migration à chaud. Pour en savoir plus, consultez Expérience de maintenance pour les instances H4D.
Remplacez les valeurs suivantes pour les commandes des sections suivantes :
- PROJECT_ID : ID de votre projetGoogle Cloud .
- CLUSTER_NAME : nom de votre cluster.
- CONTROL_PLANE_LOCATION : emplacement Compute Engine du plan de contrôle de votre cluster. Indiquez une région pour les clusters régionaux ou une zone pour les clusters zonaux. Les clusters régionaux sont recommandés pour les charges de travail de production. Pour les clusters régionaux, la région doit inclure une zone dans laquelle H4D est disponible. Pour les clusters zonaux, la zone doit être disponible pour H4D.
- COMPUTE_ZONE : zone de votre pool de nœuds. Il doit s'agir d'une zone dans laquelle H4D est disponible. Vous ne pouvez pas créer de pool de nœuds multizone si vous souhaitez que les nœuds H4D fonctionnent avec RDMA.
- RDMA_NETWORK_PREFIX : préfixe du réseau RDMA (par exemple, h4d-rdma).
- RDMA_SUBNET_CIDR : plage CIDR du sous-réseau RDMA. Assurez-vous que cette plage ne chevauche pas les réseaux par défaut du cluster.
- NODE_POOL_NAME : nom de votre pool de nœuds H4D.
- NODE_COUNT : nombre de nœuds H4D à créer dans le pool de nœuds.
- H4D_MACHINE_TYPE : type de machine H4D à utiliser (par exemple, h4d-highmem-192-lssd).

Créer des VPC et des sous-réseaux

Configurez le cloud privé virtuel (VPC) et le sous-réseau par défaut pour le cluster. Pour la carte d'interface réseau (NIC) RDMA, créez un VPC et un sous-réseau dédiés. Le VPC créé en suivant les instructions ci-dessous utilise, si nécessaire, un profil de réseau RDMA.

Créez un VPC HPC pour les cartes d'interface réseau RDMA :

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

Créez un sous-réseau pour le réseau 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

Créer un cluster GKE avec le multiréseau

Créez le cluster GKE avec le multiréseau activé. Vous pouvez également fournir explicitement les plages CIDR secondaires pour les services et les pods avec cette commande.

Exécutez la commande suivante :

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 vous utilisez ces options facultatives, remplacez les valeurs supplémentaires suivantes :

SERVICE_CIDR : plage CIDR secondaire pour les services.
POD_CIDR : plage CIDR secondaire des pods.

Lorsque vous utilisez ces indicateurs, vérifiez que les plages CIDR ne chevauchent pas les plages de sous-réseaux pour les réseaux de nœuds supplémentaires. Par exemple, SERVICE_CIDR=10.65.0.0/19 et POD_CIDR=10.64.0.0/19.

Créer des objets réseau GKE

Configurez le réseau VPC à l'aide des ensembles de paramètres réseau GKE. Appliquez les objets GKENetworkParamSet et 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

Créer un pool de nœuds H4D

Créez un pool de nœuds qui utilise H4D et se connecte au réseau RDMA. Vous pouvez utiliser des nœuds H4D liés à une réservation et un placement compact. Vous pouvez également utiliser des nœuds H4D provisionnés avec le démarrage flexible. Sélectionnez l'onglet correspondant à votre option de consommation :

Liée à la réservation

Créez une règle de ressources pour l'emplacement compact. L'emplacement compact optimise les performances des charges de travail HPC à couplage fort, qui s'exécutent sur plusieurs nœuds, en veillant à ce que les nœuds soient physiquement situés les uns par rapport aux autres dans une zone.

Exécutez la commande suivante :
```
gcloud compute resource-policies create group-placement POLICY_NAME \
    --region REGION --collocation collocated
```
Remplacez les valeurs suivantes :
- POLICY_NAME : nom de la stratégie de ressource (par exemple, h4d-compact).
- REGION : région de votre cluster.

Créez un pool de nœuds qui utilise H4D et se connecte au réseau 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

Remplacez MAX_UNAVAILABLE par le nombre maximal de nœuds pouvant être indisponibles simultanément lors d'une mise à niveau du pool de nœuds. Pour les emplacements compacts, nous vous recommandons d'effectuer des mises à niveau rapides, sans mise à niveau de la surutilisation, afin d'optimiser la probabilité de trouver des nœuds colocalisés lors des mises à niveau.

Démarrage Flex

Créez un pool de nœuds qui utilise des nœuds H4D provisionnés avec un démarrage flexible et qui se connecte au réseau 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

Remplacez MAX_NODES par le nombre maximal de nœuds pour le scaling automatique du pool de nœuds spécifié par zone.

Préparer votre image Docker

Préparez votre image à l'aide de l'exemple de fichier Dockerfile suivant :

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

Bonne pratique :

Rocky 8 est l'image basée sur un conteneur recommandée qui est compatible avec RDMA. Il est possible que le pilote iRDMA ne soit pas encore largement disponible dans d'autres distributions Linux.

Configurer vos fichiers manifestes pour RDMA

Activez RDMA en ajoutant les annotations suivantes aux métadonnées de votre pod :

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

Tester RDMA avec rping

Vérifiez la fonctionnalité RDMA en exécutant rping entre un pod de serveur et un pod de client :

Sur le pod du serveur, exécutez la commande rping :
```
rping -s
```

Sur le pod client, exécutez la commande rping :

rping -c -C 2 -d -a SERVER_IP

Remplacez SERVER_IP par l'adresse IP du pod du serveur.

Si l'opération réussit, le résultat est semblable à ceci :

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

Étapes suivantes

En savoir plus sur le calcul hautes performances
Certaines charges de travail HPC nécessitent une interface MPI (Message Passing Interface) pour exécuter des charges de travail multinoeuds à couplage fort avec RDMA. Pour en savoir plus sur la configuration de MPI dans votre cluster pour vos nœuds H4D, consultez Exécuter des charges de travail MPI sur GKE H4D.