Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Créer un cluster GKE avec Pathways

Cette page explique aux administrateurs de plates-formes et aux ingénieurs en machine learning (ML) comment créer un cluster Google Kubernetes Engine (GKE) configuré pour les charges de travail basées sur Pathways. Vous pouvez provisionner automatiquement des clusters préconfigurés à l'aide de Cluster Toolkit ou créer des clusters manuellement à l'aide de la Google Cloud CLI.

Avant de commencer

Avant de continuer, assurez-vous de remplir les conditions préalables suivantes :

Installez la gcloud CLI.
Installez kubectl et gke-gcloud-auth-plugin.
Si vous utilisez Cluster Toolkit, configurez Cluster Toolkit et mettez-le à jour vers la dernière version.
Activez l'API Kubernetes Engine.
Vérifiez que vous disposez d'un quota de TPU suffisant ou d'une réservation de TPU pour les tranches de TPU que vous souhaitez créer.

Configurer votre environnement local

Connectez-vous à la gcloud CLI avec vos identifiants Google Cloud :

gcloud auth login

Si vous utilisez Cluster Toolkit, générez également les identifiants par défaut de l'application (ADC), qui sont utilisés par Terraform :

gcloud auth application-default login

Créer un cluster GKE

Dans l'exemple suivant, vous allez créer un cluster avec des pools de nœuds TPU v6e 2x4. Vous pouvez créer un cluster à l'aide de Cluster Toolkit ou de la gcloud CLI.

Cluster Toolkit

Déployez un cluster GKE TPU en suivant les instructions de la section Déployer un cluster GKE TPU v6e. Pour obtenir un aperçu de toutes les options de déploiement de TPU, consultez Présentation des déploiements Cloud TPU.

Lorsque vous configurez votre plan de déploiement, procédez comme suit :
- Définissez enable_pathways_for_tpus sur true (activé par défaut dans les plans TPU de Cluster Toolkit). Ce paramètre provisionne automatiquement le pool de nœuds de processeur cpu-np (n4-standard-64) et les configurations Kueue requis pour le contrôleur Pathways. Cluster Toolkit n'applique la configuration Kueue Pathways par défaut que si vous ne spécifiez pas de fichier de configuration Kueue personnalisé dans la variable kueue_configuration_path.
- Définissez num_slices sur le nombre de pools de nœuds de tranche TPU requis pour votre charge de travail.
- Définissez tpu_topology sur la topologie de tranche de TPU que vous avez sélectionnée (par exemple, 2x4 ou 4x4).
- Sélectionnez une option de consommation. Par défaut, le fichier de déploiement TPU v6e consomme une réservation de TPU spécifique. Spécifiez donc le nom de la réservation dans la variable reservation_affinity. Pour utiliser une autre option de consommation, consultez Options de consommation GKE.
Vérifiez que les nœuds du cluster ont un STATUS de Ready :
```
kubectl get nodes
```
Après avoir créé le cluster, vous pouvez envoyer des charges de travail Pathways à l'aide de la commande gcluster job submit avec les options --pathways et --pathways-gcs-location. Pour en savoir plus, consultez Exécuter des charges de travail avec Pathways.

gcloud

Pour créer un cluster GKE et le configurer pour exécuter des charges de travail Pathways, procédez comme suit :

Définissez les variables d'environnement suivantes :
```
CLUSTER=GKE_CLUSTER_NAME
PROJECT=PROJECT_ID
ZONE=ZONE
REGION=REGION
CLUSTER_VERSION=GKE_CLUSTER_VERSION
PW_CPU_MACHINE_TYPE="n2-standard-64"
NETWORK=NETWORK
SUBNETWORK=SUB_NETWORK
CLUSTER_NODEPOOL_COUNT=3
TPU_MACHINE_TYPE="ct6e-standard-4t"
WORKERS_PER_SLICE=2
TOPOLOGY="2x4"
NUM_CPU_NODES=1
```
Remplacez les éléments suivants :
- GKE_CLUSTER_NAME : nom de votre cluster GKE.
- PROJECT_ID : ID de votre projet Google Cloud .
- ZONE : zone dans laquelle vous créez le cluster. Choisissez une zone où les TPU v6e sont disponibles. Pour en savoir plus, consultez Régions et zones Cloud TPU.
- REGION (facultatif) : région dans laquelle vous créez des ressources si vous utilisez un cluster régional.
- GKE_CLUSTER_VERSION (facultatif) : version du cluster GKE. Utilisez la version 1.32.2-gke.1475000 ou une version ultérieure, et choisissez une version bénéficiant d'une assistance standard. Pour en savoir plus, consultez le calendrier de publication de GKE. Si vous ne spécifiez pas de version, supprimez l'option --cluster-version de la commande gcloud container clusters create suivante.
- NETWORK : (facultatif) nom d'un réseau cloud privé virtuel (VPC). Le réseau doit exister avant que vous ne créiez le cluster. Si vous ne spécifiez pas de réseau, supprimez l'option --network de la commande gcloud container clusters create suivante.
- SUB_NETWORK : (facultatif) nom d'un sous-réseau. Le sous-réseau doit exister avant que vous créiez le cluster. Si vous ne spécifiez pas de sous-réseau, supprimez l'option --subnetwork de la commande gcloud container clusters create suivante.
Cet exemple définit les valeurs par défaut des variables restantes, que vous pouvez modifier pour votre charge de travail :
- PW_CPU_MACHINE_TYPE : type de machine du pool de nœuds par défaut du cluster et du pool de nœuds de processeur qui exécute la tête Pathways (le gestionnaire de ressources et le proxy Pathways).
- NUM_CPU_NODES : nombre de nœuds dans le pool de nœuds CPU.
- CLUSTER_NODEPOOL_COUNT : nombre de tranches de TPU. Chaque tranche est un pool de nœuds distinct.
- TPU_MACHINE_TYPE et TOPOLOGY : type de machine TPU et topologie TPU de chaque tranche.
- WORKERS_PER_SLICE : nombre de nœuds dans chaque tranche, qui correspond au nombre de puces TPU dans la topologie divisé par le nombre de puces par nœud. Par exemple, une topologie 2x4 comporte huit puces et un nœud ct6e-standard-4t comporte quatre puces. Chaque tranche comporte donc deux nœuds.

Créez un cluster GKE à l'aide de la commande gcloud container clusters create :

gcloud container clusters create ${CLUSTER} \
    --project=${PROJECT} \
    --zone=${ZONE} \
    --cluster-version=${CLUSTER_VERSION} \
    --scopes=storage-full,gke-default,cloud-platform \
    --machine-type=${PW_CPU_MACHINE_TYPE} \
    --network=${NETWORK} \
    --subnetwork=${SUBNETWORK}

Créez les pools de nœuds de tranche TPU à l'aide de la commande gcloud container node-pools create :

for i in $(seq 1 ${CLUSTER_NODEPOOL_COUNT}); do
    gcloud container node-pools create "tpu-np-${i}" \
        --project=${PROJECT} \
        --zone=${ZONE} \
        --cluster=${CLUSTER} \
        --machine-type=${TPU_MACHINE_TYPE} \
        --num-nodes=${WORKERS_PER_SLICE} \
        --placement-type=COMPACT \
        --tpu-topology=${TOPOLOGY} \
        --scopes=storage-full,gke-default,cloud-platform \
        --workload-metadata=GCE_METADATA
done

Ces commandes ne ciblent pas une réservation spécifique. Pour utiliser une réservation TPU, ajoutez les options --reservation-affinity=specific et --reservation=RESERVATION_NAME, où RESERVATION_NAME est le nom de votre réservation TPU. Pour utiliser des VM Spot, ajoutez l'option --spot.

Créez un pool de nœuds CPU pour le nœud principal Pathways, qui exécute le gestionnaire de ressources et le proxy Pathways. Nommez le pool de nœuds cpu-np afin que la commande gcluster job submit --pathways puisse le détecter :
```
gcloud container node-pools create cpu-np \
    --project=${PROJECT} \
    --zone=${ZONE} \
    --cluster=${CLUSTER} \
    --machine-type=${PW_CPU_MACHINE_TYPE} \
    --num-nodes=${NUM_CPU_NODES} \
    --scopes=storage-full,gke-default,cloud-platform \
    --workload-metadata=GCE_METADATA
```
Remarque : Les charges de travail Pathways stockent les fichiers temporaires et le code compilé mis en cache dans un bucket Cloud Storage. Comme les pools de nœuds de cet exemple utilisent --workload-metadata=GCE_METADATA, les conteneurs Pathways accèdent à Cloud Storage à l'aide du compte de service du nœud. Par défaut, ce compte est le compte de service Compute Engine par défaut. Attribuez à ce compte de service le rôle d'administrateur des objets de l'espace de stockage (roles/storage.objectAdmin) sur le bucket.
Obtenez les identifiants du cluster et définissez l'espace de noms par défaut pour kubectl :

Remarque : Si vous utilisez un cluster zonal, comme celui de cet exemple, spécifiez --zone. Si vous utilisez un cluster régional, remplacez --zone=${ZONE} par --region=${REGION}.
```
gcloud container clusters get-credentials ${CLUSTER} \
    --zone=${ZONE} \
    --project=${PROJECT} \
    && kubectl config set-context --current --namespace=default
```

Pour utiliser l'architecture Pathways sur votre cluster GKE, installez l'API JobSet :

kubectl apply --server-side -f https://github.com/kubernetes-sigs/jobset/releases/download/v0.12.0/manifests.yaml

Vérifiez que les nœuds ont un STATUS de Ready et que le pod jobset-controller-manager a un STATUS de Running :

kubectl get nodes
kubectl get pods --namespace=jobset-system

Le résultat ressemble à ce qui suit :

NAME                                      STATUS   ROLES    AGE   VERSION
gke-cluster-cpu-np-12345678-abcd          Ready    <none>   5m    v1.32.2-gke.1475000
gke-cluster-tpu-np-1-12345678-efgh        Ready    <none>   5m    v1.32.2-gke.1475000
...
NAME                                         READY   STATUS    RESTARTS   AGE
jobset-controller-manager-6f7b8c9d4-xyz12    1/1     Running   0          2m

Effectuer un nettoyage

Pour éviter que les ressources utilisées sur cette page ne soient facturées sur votre compte Google Cloud , supprimez le cluster lorsque vous avez terminé :

Cluster Toolkit : détruisez le déploiement en exécutant la commande suivante :
```
./gcluster destroy DEPLOYMENT_FOLDER_NAME
```
Remplacez DEPLOYMENT_FOLDER_NAME par le nom de votre dossier de déploiement.

gcloud CLI : supprimez le cluster GKE et ses pools de nœuds en exécutant la commande suivante :

gcloud container clusters delete ${CLUSTER} \
    --project=${PROJECT} \
    --zone=${ZONE}