Déployer un cluster Slurm sur Compute Engine

Ce tutoriel explique comment déployer un cluster Slurm sur Compute Engine. Le gestionnaire de ressources Slurm est un gestionnaire de ressources courant utilisé dans de nombreux centres de calcul hautes performances. Pour en savoir plus sur la terminologie du calcul hautes performances et les cas d'utilisation, consultez la page Utiliser des clusters pour les calculs techniques à grande échelle dans le cloud.

Le schéma suivant illustre la configuration que vous allez créer en suivant ce tutoriel.

Schéma montrant l'architecture d'un cluster Slurm installé sur Compute Engine.

En tant que gestionnaire de charge de travail de cluster, Slurm assure les fonctions suivantes :

  • Allocation de ressources (nœuds de calcul) aux utilisateurs
  • Fourniture d'un cadre pour le démarrage, l'exécution et la surveillance des tâches sur les nœuds
  • Gestion des tâches en attente dans une file d'attente

Dans ce tutoriel, nous allons déployer une architecture de cluster simplifiée qui accepte quelques utilisateurs exécutant une charge de travail dans une application unique. Vous pouvez utiliser d'autres configurations pour les déploiements de charges de travail multiples, les déploiements de production à grande échelle et les déploiements hybrides compatibles avec les clusters sur site ou multicloud. Ces configurations ne seront cependant pas traitées dans le cadre de ce tutoriel.

Dans ce tutoriel, vous allez interagir avec le système grâce au nœud de connexion (head). Une fois le cluster déployé, vous allez vous connecter en SSH au nœud de connexion, installer les applications et utiliser les outils de ligne de commande Slurm pour envoyer des tâches de calcul. Le planificateur Slurm, qui s'exécute sur le nœud de contrôleur, planifie les tâches mises en file d'attente en mettant en correspondance les ressources disponibles avec les exigences des tâches. Il gère aussi l'exécution des tâches sur les nœuds de calcul. Le serveur NFS fournit un espace partagé commun pour les fichiers.

Objectifs

  • Utilisez Terraform pour déployer un cluster Slurm.
  • Exécuter une tâche avec Slurm.
  • Demander des informations au cluster et surveiller les tâches en cours d'exécution dans Slurm.
  • Procéder à un autoscaling des nœuds pour s'adapter aux paramètres et aux exigences des tâches.

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Compute Engine and Deployment Manager.

    Activer les API

  5. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  6. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  7. Activer les API Compute Engine and Deployment Manager.

    Activer les API

  8. Dans Cloud Console, activez Cloud Shell.

    Activer Cloud Shell

    En bas de la fenêtre de Cloud Console, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel le SDK Cloud est déjà installé (y compris l'outil de ligne de commande gcloud), et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

Déployer le cluster Slurm

Dans cette section, vous allez préparer la configuration du cluster, déployer le cluster Slurm sur Google Cloud à l'aide de Deployment Manager, puis vérifier que le cluster est opérationnel.

Préparer la configuration du cluster

  1. Dans Cloud Shell, clonez le dépôt GitHub slurm-gcp :

    git clone https://github.com/SchedMD/slurm-gcp.git
    
  2. Définissez les variables d'environnement suivantes :

    export CLUSTER_NAME="cluster-name"
    export CLUSTER_ZONE="cluster-zone"
    

    Remplacez l'élément suivant :

    • cluster-name : nom unique du cluster.
    • cluster-zone : zone dans laquelle s'effectue le déploiement du cluster.
  3. Dans le dossier slurm-gcp/tf/examples/basic, copiez le fichier basic.tfvars.example dans le fichier basic.tfvars :

    cd slurm-gcp/tf/examples/basic
    cp basic.tfvars.example basic.tfvars
    
  4. Utilisez la commande sed pour modifier le fichier basic.tfvars de votre environnement :

    sed -i "s/\(cluster_name.*= \)\"\(.*\)\"/\1\"${CLUSTER_NAME}\"/" basic.tfvars
    sed -i "s/<project>/$(gcloud config get-value core/project)/" basic.tfvars
    sed -i "s/\(zone.*= \)\"\(.*\)\"/\1\"${CLUSTER_ZONE}\"/" basic.tfvars
    
  5. (Facultatif) Dans un éditeur de texte, personnalisez le fichier basic.tfvars pour votre environnement en modifiant les valeurs prédéfinies :

    • machine_type : pour utiliser un type de machine différent pour les nœuds de calcul du cluster, modifiez cette valeur. Par exemple, modifiez cette valeur si vous avez besoin de plus de cœurs de processeur ou de mémoire qu'il n'y en a sur le type de machine par défaut n1-standard-2. Pour en savoir plus, consultez Types de machines.
    • compute_disk_type : pour utiliser des disques SSD sur des nœuds de calcul, remplacez cette valeur par pd-ssd.
    • compute_disk_size_gb : pour utiliser des disques plus ou moins grands associés à vos nœuds de calcul, modifiez cette valeur.
  6. (Facultatif) Dans un éditeur de texte, personnalisez davantage le fichier basic.tfvars pour votre environnement en supprimant les commentaires des autres déclarations de variables de Terraform.

Déployer le cluster Slurm à l'aide de Terraform

  1. Dans Cloud Shell, initialisez le répertoire de travail pour Terraform :

    terraform init
    
  2. Déployez votre cluster sur Google Cloud à l'aide de Terraform :

    terraform apply -var-file=basic.tfvars
    

    Le résultat ressemble à ce qui suit :

    terraform apply -var-file=basic.tfvars -auto-approve
    module.slurm_cluster_controller.data.google_compute_default_service_account.default: Refreshing state...
    module.slurm_cluster_login.data.google_compute_default_service_account.default: Refreshing state...
    module.slurm_cluster_network.google_compute_network.cluster_network[0]: Creating...
    module.slurm_cluster_network.google_compute_network.cluster_network[0]: Still creating... [10s elapsed]
    module.slurm_cluster_network.google_compute_network.cluster_network[0]: Still creating... [20s elapsed]
    module.slurm_cluster_network.google_compute_network.cluster_network[0]: Creation complete after 22s [id=projects/myproject/global/networks/mycluster-network]
    module.slurm_cluster_network.google_compute_router.cluster_router[0]: Creating...
    module.slurm_cluster_network.google_compute_subnetwork.cluster_subnet[0]: Creating...
    module.slurm_cluster_network.google_compute_firewall.cluster_iap_ssh_firewall[0]: Creating...
    module.slurm_cluster_network.google_compute_firewall.cluster_internal_firewall[0]: Creating...
    module.slurm_cluster_network.google_compute_router.cluster_router[0]: Still creating... [10s elapsed]
    module.slurm_cluster_network.google_compute_subnetwork.cluster_subnet[0]: Still creating... [10s elapsed]
    module.slurm_cluster_network.google_compute_firewall.cluster_iap_ssh_firewall[0]: Still creating... [10s elapsed]
    module.slurm_cluster_network.google_compute_firewall.cluster_internal_firewall[0]: Still creating... [10s elapsed]
    module.slurm_cluster_network.google_compute_firewall.cluster_internal_firewall[0]: Creation complete after 11s [id=projects/myproject/global/firewalls/mycluster-allow-internal]
    module.slurm_cluster_network.google_compute_firewall.cluster_iap_ssh_firewall[0]: Creation complete after 11s [id=projects/myproject/global/firewalls/mycluster-allow-iap]
    module.slurm_cluster_network.google_compute_router.cluster_router[0]: Creation complete after 11s [id=projects/myproject/regions/us-central1/routers/mycluster-router]
    module.slurm_cluster_network.google_compute_subnetwork.cluster_subnet[0]: Still creating... [20s elapsed]
    module.slurm_cluster_network.google_compute_subnetwork.cluster_subnet[0]: Creation complete after 21s [id=projects/myproject/regions/us-central1/subnetworks/mycluster-us-central1]
    module.slurm_cluster_network.google_compute_router_nat.cluster_nat[0]: Creating...
    module.slurm_cluster_login.google_compute_instance.login_node[0]: Creating...
    module.slurm_cluster_controller.google_compute_instance.controller_node[0]: Creating...
    module.slurm_cluster_network.google_compute_router_nat.cluster_nat[0]: Still creating... [10s elapsed]
    module.slurm_cluster_login.google_compute_instance.login_node[0]: Still creating... [10s elapsed]
    module.slurm_cluster_controller.google_compute_instance.controller_node[0]: Still creating... [10s elapsed]
    module.slurm_cluster_network.google_compute_router_nat.cluster_nat[0]: Still creating... [20s elapsed]
    module.slurm_cluster_login.google_compute_instance.login_node[0]: Still creating... [20s elapsed]
    module.slurm_cluster_controller.google_compute_instance.controller_node[0]: Still creating... [20s elapsed]
    module.slurm_cluster_network.google_compute_router_nat.cluster_nat[0]: Creation complete after 22s [id=myproject/us-central1/mycluster-router/mycluster-nat]
    module.slurm_cluster_login.google_compute_instance.login_node[0]: Still creating... [30s elapsed]
    module.slurm_cluster_controller.google_compute_instance.controller_node[0]: Still creating... [30s elapsed]
    module.slurm_cluster_controller.google_compute_instance.controller_node[0]: Creation complete after 34s [id=projects/myproject/zones/us-central1-a/instances/mycluster-controller]
    module.slurm_cluster_login.google_compute_instance.login_node[0]: Creation complete after 35s [id=projects/myproject/zones/us-central1-a/instances/mycluster-login0]
    
    Apply complete! Resources: 8 added, 0 changed, 0 destroyed.
    
    Outputs:
    
    controller_network_ips = [
      [
        "10.0.0.2",
      ],
    ]
    login_network_ips = [
      [
        "10.0.0.3",
      ],
    ]
    
  3. La configuration du cluster prend entre 5 et 10 minutes. Suivez la progression de la configuration à l'aide de la commande suivante :

    gcloud compute ssh ${CLUSTER_NAME}-controller \
        --command "sudo journalctl -fu google-startup-scripts.service" \
        --zone $CLUSTER_ZONE
    

    Une fois le script terminé, votre cluster Slurm est prêt à être utilisé. Le résultat se termine par la ligne suivante :

    Started Google Compute Engine Startup Scripts.
    
  4. Pour arrêter de suivre la configuration, appuyez sur Control+C.

Vérifier que le cluster est opérationnel

  1. Dans Cloud Shell, vérifiez que le cluster est prêt en vous connectant au nœud de connexion à l'aide de la commande suivante :

    export CLUSTER_LOGIN_NODE=$(gcloud compute instances list \
        --zones ${CLUSTER_ZONE} \
        --filter="name ~ .*login." \
        --format="value(name)" | head -n1)
    gcloud compute ssh ${CLUSTER_LOGIN_NODE} \
        --zone $CLUSTER_ZONE
    

    Le cluster est prêt lorsque le résultat de la commande ressemble à ceci :

                                     SSSSSSS
                                    SSSSSSSSS
                                    SSSSSSSSS
                                    SSSSSSSSS
                            SSSS     SSSSSSS     SSSS
                           SSSSSS               SSSSSS
                           SSSSSS    SSSSSSS    SSSSSS
                            SSSS    SSSSSSSSS    SSSS
                    SSS             SSSSSSSSS             SSS
                   SSSSS    SSSS    SSSSSSSSS    SSSS    SSSSS
                    SSS    SSSSSS   SSSSSSSSS   SSSSSS    SSS
                           SSSSSS    SSSSSSS    SSSSSS
                    SSS    SSSSSS               SSSSSS    SSS
                   SSSSS    SSSS     SSSSSSS     SSSS    SSSSS
              S     SSS             SSSSSSSSS             SSS     S
             SSS            SSSS    SSSSSSSSS    SSSS            SSS
              S     SSS    SSSSSS   SSSSSSSSS   SSSSSS    SSS     S
                   SSSSS   SSSSSS   SSSSSSSSS   SSSSSS   SSSSS
              S    SSSSS    SSSS     SSSSSSS     SSSS    SSSSS    S
        S    SSS    SSS                                   SSS    SSS    S
        S     S                                                   S     S
                    SSS
                    SSS
                    SSS
                    SSS
     SSSSSSSSSSSS   SSS   SSSS       SSSS    SSSSSSSSS   SSSSSSSSSSSSSSSSSSSS
    SSSSSSSSSSSSS   SSS   SSSS       SSSS   SSSSSSSSSS  SSSSSSSSSSSSSSSSSSSSSS
    SSSS            SSS   SSSS       SSSS   SSSS        SSSS     SSSS     SSSS
    SSSS            SSS   SSSS       SSSS   SSSS        SSSS     SSSS     SSSS
    SSSSSSSSSSSS    SSS   SSSS       SSSS   SSSS        SSSS     SSSS     SSSS
     SSSSSSSSSSSS   SSS   SSSS       SSSS   SSSS        SSSS     SSSS     SSSS
             SSSS   SSS   SSSS       SSSS   SSSS        SSSS     SSSS     SSSS
             SSSS   SSS   SSSS       SSSS   SSSS        SSSS     SSSS     SSSS
    SSSSSSSSSSSSS   SSS   SSSSSSSSSSSSSSS   SSSS        SSSS     SSSS     SSSS
    SSSSSSSSSSSS    SSS    SSSSSSSSSSSSS    SSSS        SSSS     SSSS     SSSS
    
  2. Pour quitter le cluster, appuyez sur Control+D.

  3. Lorsque le cluster est prêt, planifiez une tâche pour vérifier qu'il fonctionne correctement. Cette tâche exécute la commande hostname sur plusieurs nœuds du cluster.

    gcloud compute ssh ${CLUSTER_LOGIN_NODE} \
        --command 'sbatch -N2 --wrap="srun hostname"' --zone $CLUSTER_ZONE
    
    gcloud compute ssh ${CLUSTER_LOGIN_NODE} \
        --command 'cat slurm-*.out'  --zone $CLUSTER_ZONE
    

    Le résultat ressemble à ce qui suit :

    helloworld-compute1
    helloworld-compute2
    

    Votre cluster est maintenant opérationnel.

Procéder à l'autoscaling du cluster Slurm

Lorsque vous déployez un cluster Slurm, vous spécifiez des valeurs pour les propriétés max_node_count et static_node_count. La valeur max_node_count détermine le nombre maximal de nœuds de calcul que votre cluster peut exécuter. La valeur static_node_count indique le nombre de nœuds de calcul qui restent toujours en cours d'exécution. Par défaut, dans le fichier slurm-cluster.yaml, max_node_count est défini sur 10 et static_node_count sur 2.

La différence entre ces deux nombres, max_node_count - static_node_count, correspond au nombre de nœuds éphémères dans le cluster. Les nœuds éphémères sont créés à la demande en réponse aux requêtes de planification des tâches. Une fois que la tâche pour laquelle ils ont été créés se termine, ils sont détruits, sauf si le cluster peut les réutiliser pour exécuter d'autres tâches. Sur Google Cloud, le mécanisme d'économie d'énergie de Slurm procède à l'autoscaling des clusters en n'instanciant des nœuds éphémères que lorsque c'est nécessaire.

  1. Dans Cloud Shell, connectez-vous au nœud de connexion du cluster :

    gcloud compute ssh ${CLUSTER_LOGIN_NODE} --zone $CLUSTER_ZONE
    
  2. Affichez le nombre de nœuds :

    sinfo
    

    Le résultat ressemble à ce qui suit :

    PARTITION AVAIL TIMELIMIT  NODES  STATE   NODELIST
    debug*    up    infinite   8      idle~   demo-compute[3-10]
    debug*    up    infinite   2      idle    demo-compute[1-2]
    

    Sur la première ligne, le suffixe ~ de la valeur idle dans la colonne STATE indique que les huit nœuds éphémères sont en mode économie d'énergie.

  3. Pour procéder à l'autoscaling du cluster, créez trois nœuds éphémères à l'aide de la commande suivante :

    sbatch -N5 --wrap="srun hostname"
    

    Le résultat ressemble à ce qui suit :

    Submitted batch job JOB_ID
    
  4. Affichez à nouveau le nombre de nœuds à l'aide de la commande suivante :

    sinfo
    

    Le résultat ressemble à ce qui suit :

    PARTITION AVAIL  TIMELIMIT  NODES  STATE   NODELIST
    debug*    up     infinite   3      alloc#  demo-compute[3-5]
    debug*    up     infinite   5      idle~   demo-compute[6-10]
    debug*    up     infinite   2      idle    demo-compute[1-2]
    

    Sur la première ligne, le suffixe # de la valeur alloc dans la colonne STATE indique que trois nœuds éphémères ont été créés. Une fois que ces nœuds supplémentaires ont été créés et configurés, ils exécutent la tâche, puis sont détruits après un court délai.

  5. Pour quitter le cluster, appuyez sur Control+D.

Nettoyer

Le moyen le plus simple d'éviter la facturation consiste à supprimer le projet Cloud que vous avez créé pour le tutoriel. Vous pouvez également supprimer les différentes ressources.

Supprimer le projet

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer le cluster Slurm

  • Supprimez le cluster à l'aide de la commande suivante :

    terraform destroy -var-file=basic.tfvars
    

Étape suivante

  • Explorez des architectures de référence, des schémas, des tutoriels et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.