Créer un cluster

Si vous êtes intéressé par les clusters d'entraînement Gemini Enterprise Agent Platform, contactez votre représentant commercial pour y accéder.

Cette page fournit la méthode directe basée sur l'API pour créer et gérer un cluster d'entraînement. Vous apprendrez à définir la configuration complète de votre cluster, y compris les nœuds de connexion, les partitions GPU hautes performances comme la série A4 et les paramètres de l'orchestrateur Slurm, dans un fichier JSON. Vous apprendrez également à utiliser les appels d'API REST et curl pour déployer cette configuration, créer le cluster et gérer son cycle de vie avec les opérations GET, LIST, UPDATE et DELETE.

Définir la configuration du cluster

Créez un fichier JSON pour définir la configuration complète de votre cluster d'entraînement.

Si votre règle d'administration interdit les adresses IP publiques sur les instances de calcul, déployez le cluster d'entraînement avec le paramètre enable_public_ips: false et utilisez Cloud NAT pour le trafic sortant vers Internet.

La première étape du provisionnement d'un cluster d'entraînement consiste à définir sa configuration complète dans un fichier JSON. Ce fichier sert de plan pour votre cluster. Il spécifie tous les éléments, du nom et des paramètres réseau au matériel de ses nœuds de connexion et de nœuds de calcul.

La section suivante fournit plusieurs fichiers de configuration JSON complets qui servent de modèles pratiques pour divers cas d'utilisation courants. Consultez cette liste pour trouver l'exemple qui correspond le mieux à vos besoins et utilisez-le comme point de départ.

Chaque exemple est suivi d'une description détaillée des principaux paramètres utilisés dans cette configuration spécifique.

GPU avec Filestore uniquement

Il s'agit de la configuration standard. Il fournit une instance Filestore qui sert de répertoire /home pour le cluster, adaptée à un usage général et au stockage des données utilisateur.

L'exemple suivant montre le contenu de gpu-filestore.json. Cette spécification crée un cluster avec une partition de GPU. Vous pouvez l'utiliser comme modèle et modifier des valeurs telles que machineType ou nodeCount pour l'adapter à vos besoins.

Pour obtenir la liste des paramètres, consultez la documentation de référence sur les paramètres. 

 {
  "display_name": "DISPLAY_NAME",
  "network": {
    "network": "projects/PROJECT_ID/global/networks/NETWORK",
    "subnetwork": "projects/PROJECT_ID/regions/REGION/subnetworks/SUBNETWORK"
  },
  "node_pools": [
    {
      "id": "login",
      "machine_spec": {
        "machine_type": "n2-standard-8"
      },
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "enable_public_ips": true,
      "zone": "ZONE",
      "boot_disk": {
        "boot_disk_type": "pd-standard",
        "boot_disk_size_gb": 200
      },
      "labels": { "example-key": "example-value" }
    },
    {
      "id": "a4",
      "machine_spec": {
        "machine_type": "a4-highgpu-8g",
        "accelerator_type": "NVIDIA_B200",
        "accelerator_count": 8,
        "reservation_affinity": {
          "reservationAffinityType": "RESERVATION_AFFINITY_TYPE",
          "key": "compute.googleapis.com/reservation-name",
          "values": [
            "projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME"
          ]
        }
      },
      "provisioning_model": "RESERVATION",
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "enable_public_ips": true,
      "zone": "ZONE",
      "boot_disk": {
        "boot_disk_type": "hyperdisk-balanced",
        "boot_disk_size_gb": 200
      },
      "labels": { "example-key": "example-value" }
    }
  ],
  "orchestrator_spec": {
    "slurm_spec": {
      "home_directory_storage": "projects/PROJECT_ID/locations/ZONE/instances/FILESTORE",
      "partitions": [
        {
          "id": "a4",
          "node_pool_ids": [
            "a4"
          ]
        }
      ],
      "login_node_pool_id": "login"
    }
  }
}

GPU avec Filestore et Managed Lustre

Cette configuration avancée inclut l'instance Filestore standard en plus d'un système de fichiers Lustre hautes performances. Choisissez cette option si vos jobs d'entraînement nécessitent un accès à haut débit à de grands ensembles de données.

Pour obtenir la liste des paramètres, consultez la documentation de référence sur les paramètres. 

{
  "display_name": "DISPLAY_NAME",
  "network": {
    "network": "projects/PROJECT_ID/global/networks/NETWORK",
    "subnetwork": "projects/PROJECT_ID/regions/REGION/subnetworks/SUBNETWORK"
  },
  "node_pools": [
    {
      "id": "login",
      "machine_spec": {
        "machine_type": "n2-standard-8"
      },
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "enable_public_ips": true,
      "zone": "ZONE",
      "boot_disk": {
        "boot_disk_type": "pd-standard",
        "boot_disk_size_gb": 200
      },
      "lustres": [
        "projects/PROJECT_ID/locations/ZONE/instances/LUSTRE"
      ]
    },
    {
      "id": "a4",
      "machine_spec": {
        "machine_type": "a4-highgpu-8g",
        "accelerator_type": "NVIDIA_B200",
        "accelerator_count": 8,
        "reservation_affinity": {
          "reservationAffinityType": "RESERVATION_AFFINITY_TYPE",
          "key": "compute.googleapis.com/reservation-name",
          "values": [
            "projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME"
          ]
        }
      },
      "provisioning_model": "RESERVATION",
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "enable_public_ips": true,
      "zone": "ZONE",
      "boot_disk": {
        "boot_disk_type": "hyperdisk-balanced",
        "boot_disk_size_gb": 200
      },
      "lustres": [
        "projects/PROJECT_ID/locations/ZONE/instances/LUSTRE"
      ]
    }
  ],
  "orchestrator_spec": {
    "slurm_spec": {
      "home_directory_storage": "projects/PROJECT_ID/locations/ZONE/instances/FILESTORE",
      "partitions": [
        {
          "id": "a4",
          "node_pool_ids": [
            "a4"
          ]
        }
      ],
      "login_node_pool_id": "login"
    }
  }
}

GPU avec script de démarrage

Cet exemple montre comment ajouter un script personnalisé à un pool de nœuds. Ce script s'exécute sur tous les nœuds de ce pool au démarrage. Pour configurer cela, ajoutez les champs concernés à la définition du pool de nœuds en plus des paramètres généraux. Pour obtenir la liste des paramètres et leur description, consultez la documentation de référence sur les paramètres. 

{
  "display_name": "DISPLAY_NAME",
  "network": {
    "network": "projects/PROJECT_ID/global/networks/NETWORK",
    "subnetwork": "projects/PROJECT_ID/regions/REGION/subnetworks/SUBNETWORK"
  },
  "node_pools": [
    {
      "id": "login",
      "machine_spec": {
        "machine_type": "n2-standard-8"
      },
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "enable_public_ips": true,
      "zone": "ZONE",
      "boot_disk": {
        "boot_disk_type": "pd-standard",
        "boot_disk_size_gb": 200
      },
      "startup_script" : "#Example script\nsudo mkdir -p /data\necho 'Script Finished'\n"
    },
    {
      "id": "a4",
      "machine_spec": {
        "machine_type": "a4-highgpu-8g",
        "accelerator_type": "NVIDIA_B200",
        "accelerator_count": 8,
        "reservation_affinity": {
          "reservationAffinityType": "RESERVATION_AFFINITY_TYPE",
          "key": "compute.googleapis.com/reservation-name",
          "values": [
            "projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME"
          ]
        }
      },
      "provisioning_model": "PROVISIONING_MODEL",
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "enable_public_ips": true,
      "zone": "ZONE",
      "boot_disk": {
        "boot_disk_type": "hyperdisk-balanced",
        "boot_disk_size_gb": 200
      },
      "startup_script" : "#Example script\nsudo mkdir -p /data\necho 'Script Finished'\n"
    }
  ],
  "orchestrator_spec": {
    "slurm_spec": {
      "home_directory_storage": "projects/PROJECT_ID/locations/ZONE/instances/FILESTORE",
      "partitions": [
        {
          "id": "a4",
          "node_pool_ids": [
            "a4"
          ]
        }
      ],
      "login_node_pool_id": "login"
    }
  }
}

Cluster CPU uniquement

Pour provisionner un environnement de cluster d'entraînement, vous devez d'abord définir sa configuration complète dans un fichier JSON. Ce fichier sert de plan pour votre cluster. Il spécifie tous les éléments, du nom et des paramètres des réseaux au matériel pour les nœuds de connexion et les nœuds de calcul.

Pour obtenir la liste des paramètres, consultez la documentation de référence sur les paramètres. 

{
  "display_name": "DISPLAY_NAME",
  "network": {
    "network": "projects/PROJECT_ID/global/networks/NETWORK",
    "subnetwork": "projects/PROJECT_ID/regions/REGION/subnetworks/SUBNETWORK"
  },
  "node_pools": [
    {
      "id": "cpu",
      "machine_spec": {
        "machine_type": "n2-standard-8"
      },
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "zone": "ZONE",
      "enable_public_ips": true,
      "boot_disk": {
        "boot_disk_type": "pd-standard",
        "boot_disk_size_gb": 120
      }
    },
    {
      "id": "login",
      "machine_spec": {
        "machine_type": "n2-standard-8"
      },
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "zone": "ZONE",
      "enable_public_ips": true,
      "boot_disk": {
        "boot_disk_type": "pd-standard",
        "boot_disk_size_gb": 120
      }
    }
  ],
  "orchestrator_spec": {
    "slurm_spec": {
      "home_directory_storage": "projects/PROJECT_ID/locations/ZONE/instances/FILESTORE",
      "partitions": [
        {
          "id": "cpu",
          "node_pool_ids": [
            "cpu"
          ]
        }
      ],
      "login_node_pool_id": "login"
    }
  }
}

Configuration Slurm avancée

Cet exemple permet de contrôler précisément Slurm en définissant les paramètres slurm.conf par nom et en exécutant des scripts de prologue et d'épilogue pour la configuration et le nettoyage automatisés des jobs. Les paramètres peuvent être définis à l'échelle du cluster, pour une seule partition ou pour un seul pool de nœuds.

Il existe trois cartes de configuration, une pour chaque enregistrement slurm.conf :

  • config sur les spécifications Slurm pour les paramètres à l'échelle du cluster
  • config sur une partition
  • Entrée node_sets pour un pool de nœuds

Pour connaître les règles concernant les noms et les valeurs des paramètres, ainsi que les paramètres refusés, consultez Cartes de configuration Slurm.

Vous n'avez pas besoin de les définir au moment de la création. Les trois cartes peuvent être modifiées sur un cluster en cours d'exécution, sans redémarrer les nœuds ni perturber les jobs en file d'attente. Consultez Mettre à jour les paramètres de configuration de Slurm. 

{
  "display_name": "DISPLAY_NAME",
  "network": {
    "network": "projects/PROJECT_ID/global/networks/NETWORK",
    "subnetwork": "projects/PROJECT_ID/regions/REGION/subnetworks/SUBNETWORK"
  },
  "node_pools": [
    {
      "id": "cpu",
      "machine_spec": {
        "machine_type": "n2-standard-8"
      },
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "zone": "ZONE",
      "enable_public_ips": true,
      "boot_disk": {
        "boot_disk_type": "pd-standard",
        "boot_disk_size_gb": 120
      }
    },
    {
      "id": "login",
      "machine_spec": {
        "machine_type": "n2-standard-8"
      },
      "scaling_spec": {
        "min_node_count": MIN_NODE_COUNT,
        "max_node_count": MAX_NODE_COUNT
      },
      "zone": "ZONE",
      "enable_public_ips": true,
      "boot_disk": {
        "boot_disk_type": "pd-standard",
        "boot_disk_size_gb": 120
      }
    }
  ],
  "orchestrator_spec": {
    "slurm_spec": {
      "home_directory_storage": "projects/PROJECT_ID/locations/ZONE/instances/FILESTORE",
      "config": {
        "PriorityType": "priority/multifactor",
        "PriorityWeightAge": "1000",
        "PriorityWeightFairshare": "10000",
        "PreemptType": "preempt/partition_prio",
        "PreemptMode": "SUSPEND,GANG",
        "SchedulerParameters": "bf_continue,bf_window=1440,bf_resolution=600",
        "AccountingStorageEnforce": "limits,qos"
      },
      "prolog_bash_scripts": [
        "#!/bin/bash\necho 'Prolog script running'"
      ],
      "epilog_bash_scripts": [
        "#!/bin/bash\necho 'Epilog script running'"
      ],
      "partitions": [
        {
          "id": "cpu",
          "node_pool_ids": [
            "cpu"
          ],
          "config": {
            "MaxTime": "4-00:00:00",
            "DefMemPerCPU": "4096",
            "PriorityTier": "20"
          }
        }
      ],
      "node_sets": [
        {
          "node_pool_id": "cpu",
          "config": {
            "Weight": "10",
            "Features": "cpu,spot"
          }
        }
      ],
      "login_node_pool_id": "login"
    }
  }
}

La carte à portée de cluster définit la priorité multifactorielle, la préemption de priorité de partition et SchedulerParameters, dont le terme bf_continue montre la forme composite : un terme nu active un indicateur, et les termes sont séparés par des virgules. La carte de partition limite la durée d'exécution du job et la mémoire par défaut pour la partition cpu uniquement, et les libellés d'entrée node_sets regroupent les nœuds afin que les jobs puissent les sélectionner avec --constraint.

Une fois votre cluster défini dans un fichier JSON, utilisez les commandes de l'API REST suivantes pour le déployer et le gérer. Les exemples utilisent un alias gcurl, qui est un raccourci authentifié pratique pour interagir avec les points de terminaison de l'API. Ces commandes couvrent l'intégralité du cycle de vie, du déploiement initial de votre cluster à sa suppression, en passant par la mise à jour d'un cluster, l'obtention de son état et la liste de tous les clusters.

Authentification

alias gcurl='curl -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json"'

Créer un fichier JSON

Créez un fichier JSON (par exemple, @cpu-cluster.json) pour spécifier la configuration de votre cluster d'entraînement de modèles.

Déployer le cluster

Une fois le fichier de configuration JSON créé, vous pouvez déployer le cluster à l'aide de l'API REST.

Définir des variables d'environnement

Avant d'exécuter la commande, définissez les variables d'environnement suivantes. Cela rend la commande API plus claire et plus facile à gérer.

  • PROJECT_ID : ID du projet Google Cloud dans lequel le cluster sera créé.
  • REGION : région Google Cloud du cluster et de ses ressources.
  • ZONE : zone Google Cloud dans laquelle les ressources du cluster seront provisionnées.
  • CLUSTER_ID : identifiant unique de votre cluster d'entraînement, qui est également utilisé comme préfixe pour nommer les ressources associées.

Exécuter la commande de création

Exécutez maintenant la commande gcurl suivante. Il utilise le fichier JSON (cpu-cluster.json dans cet exemple) comme corps de requête et les variables d'environnement que vous venez de définir pour construire le point de terminaison de l'API et les paramètres de requête. 

  gcurl -X POST -d @cpu-cluster.json https://REGION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/REGION/modelDevelopmentClusters?model_development_cluster_id=CLUSTER_ID

Une fois le déploiement lancé, un ID d'opération est généré. Veillez à copier cet ID. Vous en aurez besoin pour valider votre cluster à l'étape suivante.

  gcurl -X POST -d @cpu-cluster.json https://us-central1-aiplatform.googleapis.com/v1beta1/projects/managedtraining-project/locations/us-central1/modelDevelopmentClusters?model_development_cluster_id=training
  {
      "name": "projects/1059558423163/locations/us-central1/operations/2995239222190800896",
      "metadata": {
      "@type": "type.googleapis.com/google.cloud.aiplatform.v1beta1.CreateModelDevelopmentClusterOperationMetadata",
      "genericMetadata": {
        "createTime": "2025-10-24T14:16:59.233332Z",
        "updateTime": "2025-10-24T14:16:59.233332Z"
      },
      "progressMessage": "Create Model Development Cluster request received, provisioning..."
  }

Valider le déploiement du cluster

Suivez la progression du déploiement à l'aide de l'ID d'opération fourni lorsque vous avez déployé le cluster. Par exemple, 2995239222190800896 est l'ID d'opération dans l'exemple cité précédemment.

    gcurl https://REGION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/REGION/operations/OPERATION_ID

En résumé

L'envoi de la configuration de votre cluster avec la commande POST gcurl lance le provisionnement de votre cluster, qui est une opération asynchrone de longue durée. L'API renvoie immédiatement une réponse contenant un Operation ID. Il est essentiel de sauvegarder cet ID, car vous l'utiliserez lors des étapes suivantes pour surveiller la progression du déploiement, vérifier que le cluster a été créé correctement et gérer son cycle de vie.

Référence de paramètre

La liste suivante décrit tous les paramètres utilisés dans les exemples de configuration. Les paramètres sont organisés en groupes logiques en fonction de la ressource qu'ils configurent.

Paramètres généraux et réseau

  • DISPLAY_NAME : nom unique de votre cluster d'entraînement. La chaîne ne peut contenir que des caractères alphanumériques minuscules, doit commencer par une lettre et ne peut pas dépasser 10 caractères.
  • PROJECT_ID : ID de votre projet Google Cloud .
  • REGION : région Google Cloud dans laquelle se trouveront le cluster et ses ressources.
  • NETWORK : réseau VPC à utiliser pour les ressources du cluster.
  • ZONE : zone Google Cloud du cluster et de ses ressources.
  • SUBNETWORK : sous-réseau à utiliser pour les ressources du cluster.

Configuration du pool de nœuds

Les paramètres suivants sont utilisés pour définir les pools de nœuds pour les nœuds de connexion et de calcul.

Paramètres courants des pools de nœuds

  • ID : identifiant unique du pool de nœuds dans le cluster (par exemple, "login", "a4", "cpu").
  • PROVISIONING_MODEL : modèle de provisionnement du nœud de calcul (par exemple, ON_DEMAND, SPOT, RESERVATION, FLEX_START).
  • MACHINE_TYPE : type de machine pour le nœud de calcul (par exemple, a3-highgpu-8g, a3-megagpu-8g, a3-ultragpu-8g, a4-highgpu-8g). Pour obtenir la liste complète des types de machines compatibles, consultez Ressources de calcul.
  • MIN_NODE_COUNT : MIN_NODE_COUNT doit être identique à MAX_NODE_COUNT.
  • MAX_NODE_COUNT : pour le pool de nœuds de connexion, le MAX_NODE_COUNT doit être identique au MIN_NODE_COUNT.
  • ENABLE_PUBLIC_IPS : valeur booléenne (true ou false) permettant de déterminer si le nœud de connexion possède une adresse IP publique.
  • BOOT_DISK_TYPE : type de disque de démarrage pour le nœud de connexion (par exemple, pd-standard, pd-ssd).
  • BOOT_DISK_SIZE_GB : taille du disque de démarrage en Go pour le nœud de connexion.
  • LABELS : ensemble de paires clé/valeur permettant d'étiqueter le pool de nœuds.
  • NODE_IMAGE (correspond à node_image dans un objet node_pools) : image de VM à partir de laquelle les nœuds du pool de nœuds démarrent, sous la forme d'un chemin d'accès complet à la ressource d'image ou de famille d'images (par exemple, projects/IMAGE_PROJECT/global/images/family/IMAGE_FAMILY ). Si vous l'omettez, le pool de nœuds utilise l'image par défaut actuelle pour son type de machine, qui évolue au fil du temps. Définissez-le pour conserver le pool de nœuds sur une image spécifique. La modification de l'image d'un pool de nœuds recrée ses nœuds.

Paramètres de stockage supplémentaire

  • FILESTORES (correspond à filestores dans un objet node_pools) : liste des instances Filestore préexistantes à monter sur le pool de nœuds pour l'accès aux fichiers partagés.
  • LUSTRES (correspond à lustres dans un objet node_pools) : liste des instances Lustre préexistantes à installer sur le pool de nœuds pour un accès aux fichiers hautes performances.

Paramètres spécifiques aux nœuds de calcul

  • ACCELERATOR_TYPE : accélérateur GPU correspondant à associer aux nœuds de calcul. Valeurs acceptées :
    • NVIDIA_H100_80GB
    • NVIDIA_H100_MEGA_80GB
    • NVIDIA_H200_141GB
    • NVIDIA_B200
  • ACCELERATOR_COUNT : nombre d'accélérateurs à associer à chaque nœud de calcul.
  • RESERVATION_AFFINITY_TYPE (correspond à machine_spec.reservation_affinity.reservationAffinityType) : affinité de réservation pour le pool de nœuds. Ce paramètre doit être défini sur SPECIFIC_RESERVATION, qui est la seule valeur acceptée. Lorsque SPECIFIC_RESERVATION est utilisé, vous devez spécifier la réservation dans machine_spec.reservation_affinity.values.
  • RESERVATION_NAME : nom de la réservation à utiliser pour le pool de nœuds. Cette valeur est utilisée dans le nom complet de la ressource de réservation fourni dans machine_spec.reservation_affinity.values, par exemple projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME. Une réservation est obligatoire lorsque RESERVATION_AFFINITY_TYPE est défini sur SPECIFIC_RESERVATION.

Configuration de l'orchestrateur et du stockage

Ces champs sont définis dans le bloc orchestrator_spec.slurm_spec du fichier JSON.

Paramètres principaux de Slurm et de stockage

  • HOME_DIRECTORY_STORAGE (correspond à home_directory_storage) : nom complet de la ressource de l'instance Filestore préexistante à monter en tant que répertoire /home.
  • LOGIN_NODE_POOL_ID (correspond à login_node_pool_id) : ID du pool de nœuds à utiliser pour les nœuds de connexion.
  • partitions : liste d'objets de partition, où chaque objet nécessite un id et une liste de node_pool_ids.
  • default_partition_id (facultatif) : id de la partition utilisée pour exécuter les jobs Slurm lorsqu'aucune partition n'est spécifiée explicitement (par exemple, lors de l'exécution de sbatch sans l'option --partition). Si elle n'est pas définie, la première partition de la liste des partitions devient la partition par défaut. Par conséquent, la réorganisation de la liste modifiera la partition par défaut.

Paramètres Slurm avancés

  • prolog_bash_scripts : liste de chaînes, où chaque chaîne contient l'intégralité du contenu d'un script Bash à exécuter avant le début d'un job.
  • epilog_bash_scripts : liste de chaînes, où chaque chaîne contient l'intégralité du contenu d'un script Bash à exécuter une fois le job terminé.
  • config, partitions[].config et node_sets : paramètres Slurm définis par nom. Consultez Cartes de configuration Slurm.
  • scheduling et accounting : remplacés. Ces deux objets exposent un ensemble fixe de paramètres de priorité, de préemption et de comptabilité, chacun pouvant être défini par nom dans la carte config à portée du cluster (priority_type en tant que "PriorityType", preempt_mode en tant que "PreemptMode", etc.). Elles fonctionnent toujours pour les clusters qui les utilisent, mais les nouveaux clusters doivent utiliser config, qui accepte beaucoup plus de paramètres slurm.conf que ce sous-ensemble.

Cartes de configuration Slurm

Les paramètres Slurm sont définis par nom, dans trois mappages, un pour chaque enregistrement slurm.conf :

  • config : paramètres à l'échelle du cluster, écrits sous forme de lignes Key=Value globales.
  • partitions[].config : paramètres d'une partition, écrits sous forme de paires supplémentaires sur la ligne PartitionName= de cette partition.
  • node_sets : liste d'objets, chacun avec une carte node_pool_id et config. Les paramètres sont écrits sous forme de paires supplémentaires sur la ligne NodeName= pour les nœuds de ce pool de nœuds. Au maximum une entrée par pool de nœuds. Le pool doit être un pool de calcul du cluster, et non le pool de connexion.

Dans les trois cas, les clés sont des noms de paramètres Slurm tels que documentés par SchedMD, sans tenir compte de la casse et en ignorant les traits de soulignement. Ainsi, DefMemPerCPU, defmempercpu et def_mem_per_cpu désignent tous le même paramètre. Les valeurs sont écrites de la même manière que slurm.conf, y compris les listes séparées par des virgules telles que "PreemptMode": "SUSPEND,GANG" et les valeurs composites telles que "SchedulerParameters": "bf_window=1440,bf_resolution=600".

Chaque carte est compatible avec un sous-ensemble des paramètres slurm.conf valides pour son enregistrement, et non avec tous. Si vous avez besoin d'un paramètre non compatible, contactez votre cluster d'entraînement Gemini Enterprise Agent Platform.

Un paramètre non compatible avec le champ d'application dans lequel vous l'avez défini, ou une valeur non valide pour ce paramètre, est refusé lorsque vous envoyez la requête. L'erreur indique le nom du paramètre. Aucune donnée n'est supprimée silencieusement. Certains paramètres sont refusés pour une raison spécifique :

  • Le service gère la vérification de l'état des nœuds et la remise en file d'attente des jobs. Par conséquent, HealthCheckProgram, HealthCheckInterval, HealthCheckNodeState et RequeueExit ne peuvent pas être définis.
  • Prolog et Epilog sont définis à l'aide de prolog_bash_scripts et epilog_bash_scripts.
  • Les paramètres slurmdbd.conf, tels que StorageHost et PurgeJobAfter, ne sont pas configurables : la base de données comptable est gérée par le service.
  • Au niveau de la partition, Default est refusé. La partition par défaut est un choix à l'échelle du cluster, défini avec default_partition_id.

Configuration de l'environnement d'exécution

Ces champs sont définis dans le bloc runtime_spec du fichier JSON.

  • service_account : compte de service par défaut utilisé par le cluster lors de l'exécution de charges de travail. Si aucune valeur n'est spécifiée, le compte de service Compute Engine par défaut est utilisé. Ce champ ne peut pas être modifié après la création du cluster.

Étapes suivantes

Utilisez votre cluster d'entraînement persistant actif pour exécuter vos charges de travail de machine learning.