guix pull guix search guix show guix install guix package -l guix upgrade guix remove guix shell et Manifestes
guix-hpc et les Outils Scientifiques
Vous avez peut-être déjà rencontré ce problème frustrant : un logiciel scientifique fonctionne parfaitement sur votre ordinateur, mais impossible de le faire tourner sur le cluster de calcul (ou chez un collègue) à cause de problèmes de versions, de bibliothèques manquantes ou de conflits… C’est là qu’interviennent les conteneurs, mais aussi d’autres outils comme GNU Guix (prononcez "Guiks") ! Ce cours vous explique ce qu’est Guix, un gestionnaire de paquets différent qui offre une solution puissante à ces problèmes, particulièrement pertinente dans le contexte du Calcul Haute Performance (HPC). Oubliez (presque) tout ce que vous savez sur apt, yum ou même Conda, et préparez-vous à une nouvelle approche !
En HPC, ce problème est amplifié :
Des centaines d’utilisateurs partagent le même système.
Les logiciels scientifiques ont des dépendances complexes et parfois contradictoires (Bibliothèque A v1.0 est nécessaire pour Code 1, mais Bibliothèque A v2.0 est nécessaire pour Code 2).
Les mises à jour du système ou des modules centraux peuvent casser des workflows existants.
Assurer qu’une simulation complexe lancée aujourd’hui donnera exactement le même résultat si elle est relancée dans 6 mois (ou sur une autre machine) est un défi majeur pour la reproductibilité scientifique.
Guix aborde ces problèmes différemment des gestionnaires de paquets traditionnels ou même des conteneurs. Ses principes clés sont :
Gestion Fonctionnelle : Inspiré par le gestionnaire Nix. Chaque paquet est construit par une "fonction pure" : le même code source et les mêmes dépendances donneront toujours exactement le même résultat binaire, bit pour bit.
Isolation et Non-Interférence : Les paquets ne sont pas installés dans des endroits standards comme /usr/bin ou /usr/lib. Ils vivent dans un endroit spécial, le "magasin" (/gnu/store), et chaque version, chaque variante d’un paquet a son propre chemin unique et immuable. Fini les conflits !
Reproductibilité : Grâce à l’approche fonctionnelle et au magasin immuable, Guix peut garantir qu’un environnement logiciel défini aujourd’hui pourra être recréé identiquement demain, dans un an, ou sur une autre machine (ayant Guix).
Environnements Déclaratifs : Vous décrivez l’environnement logiciel dont vous avez besoin dans un fichier (un "manifeste"), et Guix se charge de le construire pour vous, de manière isolée et reproductible.
Contrôle Utilisateur : Chaque utilisateur gère ses propres environnements logiciels ("profils") sans avoir besoin des droits administrateur et sans affecter les autres utilisateurs.
Gestion Transactionnelle : Les mises à jour ou installations sont atomiques. Si quelque chose échoue, le système revient à l’état précédent. Vous pouvez même revenir à une version antérieure de votre environnement (rollback).
| GUIX (et NIX) sont la manière la plus aboutie pour la reproductibilité de vos calculs, très loin devant tous les autres outils, même les conteneurs ! Utilisez Guix aussi souvent que possible !!! |
Pour utiliser Guix, il faut comprendre quelques concepts clés :
Le Magasin (The Store) : /gnu/store
C’est le cœur de Guix. Tous les paquets logiciels et leurs dépendances sont stockés ici, et uniquement ici.
Chaque élément a un chemin unique basé sur un hash (une empreinte digitale) de ses entrées (code source, dépendances, options de compilation…).
Exemple de chemin : /gnu/store/s1qb3[…]py-numpy-1.21.4/lib/python3.9/site-packages/ (Note : les […] remplacent une longue chaîne de hash (suite alphanumérique)).
Ce répertoire est en lecture seule pour les utilisateurs normaux. On ne modifie jamais rien directement dans le store.
Avantage : Plusieurs versions d’un même paquet peuvent coexister sans conflit. Les dépendances sont gérées précisément.
Les Profils (Profiles)
Comme on ne peut pas utiliser directement les chemins complexes du store, Guix utilise des profils. Un profil est simplement une arborescence de liens symboliques pointant vers les éléments spécifiques dans le /gnu/store.
Votre profil par défaut se trouve généralement dans ~/.guix-profile. Lorsque vous installez un paquet avec guix install, Guix ajoute les liens nécessaires (ex: vers les exécutables dans ~/.guix-profile/bin, les bibliothèques dans ~/.guix-profile/lib…) dans ce profil.
Pour utiliser les logiciels installés dans votre profil, vous devez ajouter les chemins pertinents (comme ~/.guix-profile/bin) à vos variables d’environnement ($PATH, $LD_LIBRARY_PATH, $PYTHONPATH, etc.). Souvent, cela est fait automatiquement via un script de configuration (ex: source /etc/profile.d/guix.sh ou similaire - IMPORTANT: vérifiez la configuration locale !).
Avantage : Chaque utilisateur a son propre profil, isolé des autres. Les mises à jour créent une nouvelle génération du profil, permettant de revenir en arrière facilement.
Les Paquets (Packages)
Une définition (écrite en langage Scheme) décrivant comment construire un logiciel : où trouver le code source, quelles sont ses dépendances, comment le compiler et l’installer (dans le store).
Les Canaux (Channels)
Des dépôts (repositories Git, généralement) contenant les définitions de paquets.
Le canal par défaut est guix, fourni par le projet GNU Guix.
On peut ajouter d’autres canaux pour accéder à plus de paquets, notamment ceux spécifiques au HPC. Le canal guix-hpc est un exemple important, fournissant des versions optimisées ou des paquets non présents dans le canal guix principal (MPI, bibliothèques scientifiques…).
Les canaux sont configurés dans ~/.config/guix/channels.scm.
Explorons les commandes de base pour interagir avec Guix.
Avant de lancer les commandes guix, assurez-vous que votre environnement est correctement configuré pour trouver Guix. Cela implique souvent de sourcer un fichier de configuration une seule fois par session, ou de l’ajouter à votre .bashrc / .profile.
|
# Exemple de configuration (peut varier !) - à faire une fois par session ou mettre dans .bashrc
# Vérifiez la documentation de votre cluster !
# Exemple possible :
# export PATH="$HOME/.config/guix/current/bin${PATH:+:}$PATH"
# export GUIX_PROFILE="$HOME/.guix-profile"
# source "$GUIX_PROFILE/etc/profile"
# export GUIX_LOCPATH="$HOME/.guix-profile/lib/locale" # Pour les locales
| Cette configuration par défaut peut être modifiée par les administrateurs du cluster. Toujours vous référer à la page qui regroupe l’ensemble des spécificités du cluster IO : cluster-io-specifications |
guix pull C’est la première commande à lancer régulièrement. Elle met à jour Guix lui-même et télécharge les dernières définitions de paquets depuis les canaux configurés (dans channels.scm).
# Met à jour Guix et les canaux configurés guix pull # La sortie affiche des informations sur les canaux et les 'generations' de Guix
guix pull crée une nouvelle génération de Guix. Vous pouvez revenir à une version précédente si une mise à jour pose problème (guix pull --rollback).
|
guix search Permet de trouver des paquets disponibles dans vos canaux.
# Chercher des paquets liés à python guix search python # Chercher un paquet spécifique comme Open MPI guix search openmpi # Chercher avec une expression régulière (ex: tous les paquets hdf) # Note: les guillemets protègent l'expression régulière du shell guix search -e 'hdf.*' # Chercher un outil bioinformatique (peut venir d'un canal bio) guix search samtools
La sortie liste les paquets correspondants, leur nom, version et une courte description.
guix show Donne des informations détaillées sur un paquet (version, licence, page d’accueil, dépendances, taille…).
# Afficher les infos sur le paquet python principal guix show python # Afficher les infos sur le paquet OpenBLAS (bibliothèque d'algèbre linéaire) guix show openblas
guix install Ajoute les liens symboliques nécessaires dans votre profil par défaut (~/.guix-profile) pour rendre un paquet accessible. Guix va télécharger ou construire le paquet et toutes ses dépendances s’ils ne sont pas déjà dans le /gnu/store.
# Installer le paquet 'hello' (un programme simple qui dit bonjour) guix install hello # Essayer de lancer la commande # (Assurez-vous que ~/.guix-profile/bin est dans votre $PATH) hello # Sortie attendue: Hello, world! # Installer un outil plus utile, comme 'htop' guix install htop # Le lancer (si le PATH est correct) htop
L’installation ne fait qu’ajouter des liens symboliques dans votre profil. Le logiciel lui-même est dans /gnu/store. C’est donc très léger, les logiciels et leurs dépendances ne sont pas vraiment recopiées, ce sont juste des liens.
|
guix package -l # Lister les paquets actuellement installés dans le profil par défaut guix package -l
guix upgrade Met à jour tous les paquets de votre profil vers les dernières versions disponibles dans vos canaux (selon la dernière exécution de guix pull). Crée une nouvelle génération du profil.
# Mettre à jour tous les paquets du profil guix upgrade
guix remove Retire un paquet de votre profil (enlève les liens symboliques). Ne supprime pas le paquet du /gnu/store immédiatement (il sera nettoyé plus tard par le "ramasse-miettes" si plus aucun profil ou dépendance ne le référence). Crée une nouvelle génération.
# Supprimer htop du profil guix remove htop
Chaque fois que vous faites guix install, guix remove, ou guix upgrade, Guix crée une nouvelle génération de votre profil. C’est comme une sauvegarde de l’état de votre environnement. Si une mise à jour casse quelque chose, vous pouvez revenir à la génération précédente ! C’est la gestion transactionnelle.
*Lister les générations :
guix package --list-generations
# Exemple de sortie possible # Generation 1 2025-04-18 10:00:00 # Profil initial # Generation 2 2025-04-18 10:05:15 # Après 'guix install hello' # Generation 3 2025-04-18 10:10:30 # Après 'guix install htop' # Generation 4 2025-04-18 10:15:00 (current) # Après 'guix remove hello'
**Revenir à une génération précédente :
guix package --switch-generation=<Numéro>
# Revenir à l'état où hello et htop étaient installés (Génération 3) guix package --switch-generation=3 # Vérifier que htop est de nouveau là (si le PATH est configuré) which htop # Revenir à la dernière génération (la 4 dans notre exemple) guix package --switch-generation=4 # Ou simplement : guix package -r # Pour rollback à la précédente
Supprimer les anciennes générations : (Pour récupérer de l’espace disque potentiellement, car le store n’est nettoyé que par le ramasse-miettes).
guix package --delete-generations : Supprime toutes les générations sauf la courante.
guix package --delete-generations=<N> : Supprime la génération N spécifique.
guix package --delete-generations=2m : Supprime les générations de plus de 2 mois.
| Supprimer une génération rend le retour en arrière vers cet état impossible. |
guix shell et ManifestesInstaller tous vos paquets dans le profil par défaut peut vite devenir compliqué. Guix excelle dans la création d’environnements isolés et reproductibles pour des projets spécifiques.
Isolation des Projets : Projet A utilise libX v1, Projet B utilise libX v2. Pas de conflit !
Versions Spécifiques : Garantir l’utilisation de Python 3.8 pour un vieux projet, même si votre profil a Python 3.11.
Reproductibilité Garantie : Le cœur de l’approche Guix. Un environnement défini aujourd’hui est recréable à l’identique plus tard.
Pas de "Pollution" du Profil : Garde votre profil principal (~/.guix-profile) propre avec seulement les outils généraux.
guix shell La commande guix shell est votre outil principal pour créer des environnements à la volée, sans rien installer dans votre profil.
Syntaxe :
guix shell <paquet1> <paquet2> … — <commande_a_lancer> [args…] : Lance <commande_a_lancer> dans un environnement temporaire contenant <paquet1>, <paquet2>, etc. L’environnement disparaît après l’exécution de la commande. Le -- est important pour séparer les paquets de la commande.
guix shell <paquet1> <paquet2> … : Ouvre un nouveau shell interactif où <paquet1>, <paquet2>, etc., sont disponibles. Tapez exit pour quitter cet environnement.
cowsay temporairement# Essayer d'importer cowsay (devrait échouer si pas installé dans le profil)
python -c "import cowsay" || echo "Cowsay non trouvé initialement."
# Lancer une commande python utilisant cowsay via guix shell
# Guix télécharge/construit python et python-cowsay si nécessaire
# Le '--' permet d'invoquer une commande dans ce nouveau shell
# Le '\' à la fin de la ligne guix shell est pour la clarté multi-lignes
guix shell python python-cowsay -- \
python -c "import cowsay; cowsay.cow('Guix shell est pratique !')"
# Vérifier à nouveau : cowsay n'est TOUJOURS PAS installé dans le profil
python -c "import cowsay" || echo "Cowsay toujours pas installé après guix shell."
# Ouvrir un shell avec gcc, make, et les outils de base # gcc-toolchain inclut gcc, g++, etc. coreutils inclut ls, cat... guix shell gcc-toolchain make coreutils pkg-config # Le prompt change, vous êtes dans l'environnement Guix temporaire # Le prompt peut ressembler à : [guix shell] $ # Vérifiez les versions des outils disponibles DANS cet environnement : which gcc gcc --version make --version which pkg-config # Vous pouvez compiler un projet C ici... # cd /path/to/source/code # ./configure # Si le projet utilise autotools # make # Quitter l'environnement temporaire exit # Vérifier que gcc n'est plus disponible (sauf si installé dans votre profil) gcc --version || echo "gcc non trouvé hors de guix shell."
manifest.scm)Pour des projets plus complexes, ou pour partager facilement un environnement, on utilise un fichier Manifeste. C’est un fichier texte (nommé par convention avec l’extension .scm) qui déclare la liste des paquets nécessaires, assurant une reproductibilité parfaite.
Format : C’est un fichier en langage Scheme (une variante de Lisp). La syntaxe de base est simple.
Structure Minimale d’un fichier manifest.scm :
;;;; manifest.scm
;;; Un exemple de manifeste Guix simple
;;; Section 1: Déclarer les modules Guix nécessaires
;;; Permet à Guix de trouver les définitions des paquets que vous allez lister.
;;; Il faut ajouter une ligne (gnu packages ...) pour chaque catégorie de paquets.
(use-modules (guix packages) ; Fonctionnalité de base des manifestes
(gnu packages base) ; Pour "coreutils", "bash", etc.
(gnu packages build-tools) ; Pour "gcc-toolchain", "make", "cmake", "pkg-config"...
(gnu packages python) ; Pour "python", "python-numpy", etc.
(gnu packages science) ; Pour "hdf5", "netcdf", "gsl", etc.
(gnu packages tex) ; Pour "texlive-xyz"...
;; Ajoutez ici d'autres modules si vous utilisez des paquets
;; de catégories différentes (ex: (gnu packages maths) pour "openblas")
;; ou de canaux spécifiques (ex: (hpc packages mpi) si guix-hpc est configuré)
)
;;; Section 2: La liste des paquets désirés
;;; La fonction 'specifications->manifest' prend une liste de chaînes de caractères.
;;; Chaque chaîne est le nom d'un paquet tel que trouvé par 'guix search'.
(specifications->manifest
(list
;; Paquets de base souvent utiles
"coreutils" ; pour ls, cat, rm, etc.
"bash" ; le shell
;; Outils de compilation (si vous compilez du code)
"gcc-toolchain" ; Contient gcc, g++, gfortran, etc. (peut aussi être juste "gcc")
"make"
;"cmake" ; Décommentez si besoin
;"pkg-config" ; Décommentez si besoin
;; Paquets Python (exemple)
"python" ; Le paquet python principal (souvent Python 3)
"python-numpy"
"python-scipy"
"python-matplotlib"
"python-pandas"
;; Autres outils scientifiques (exemple)
"hdf5"
;"openmpi" ; Décommentez si besoin (le nom exact peut varier)
;; Ajoutez ici les noms exacts des autres paquets dont vous avez besoin
;; (utilisez 'guix search' pour trouver les noms)
;; "votre-outil-bioinfo"
;; "votre-librairie-specifique"
))
Utilisation avec guix shell -m : L’option -m (ou --manifest) charge l’environnement défini dans le fichier.
# Lancer une commande python DANS l'environnement défini par mon_manifest.scm guix shell -m mon_manifest.scm -- python mon_script_scientifique.py --input donnees.txt # Ouvrir un shell interactif avec cet environnement complet guix shell -m mon_manifest.scm # [guix shell] $ python --version # [guix shell] $ exit
1 Créez le fichier python_numpy_manifest.scm avec ce contenu :
+
(use-modules (guix packages) (gnu packages python)) (specifications->manifest (list "python" "python-numpy" ; Assurez-vous que ce nom est correct via 'guix search numpy' ))
2 Utilisez-le dans le terminal :
+
# Lancer python et vérifier la version de numpy depuis l'environnement du manifeste
guix shell -m python_numpy_manifest.scm -- \
python -c "import numpy; print(f'Version NumPy via Guix: {numpy.__version__}')"
# Ouvrir un shell avec cet environnement
guix shell -m python_numpy_manifest.scm
# [guix shell] $ python
# Python 3.x.y ...
# >>> import numpy
# >>> numpy.__version__
# '...'
# >>> exit()
# [guix shell] $ exit
Avantages Clés des Manifestes :
Déclaratif : Le fichier décrit l’état final désiré.
Reproductible : C’est la garantie de reproductibilité. Partagez ce fichier .scm, et l’environnement peut être recréé à l’identique.
Gestion de Versions : Intégrez votre manifest.scm à votre dépôt Git avec votre code source !
guix-hpc et les Outils ScientifiquesPour répondre aux besoins spécifiques du HPC (calcul parallèle, bibliothèques optimisées…), la communauté a créé des canaux supplémentaires, dont guix-hpc est un acteur majeur.
guix-hpcIl fournit des définitions de paquets (recettes) pour :
Implémentations MPI : OpenMPI, MPICH, souvent avec différentes options de configuration (support réseau spécifique, compilateurs…).
Bibliothèques Scientifiques Clés : PETSc, SLEPc, FFTW, ScaLAPACK, Hypre, …
Outils de Performance : TAU, Score-P, Scalasca…
Débogueurs Parallèles (parfois).
Peut inclure des variantes de bibliothèques (comme BLAS/LAPACK) liées à des implémentations optimisées (OpenBLAS, MKL si la licence le permet).
Il vient compléter le canal guix officiel.
guix-hpc (Si nécessaire et autorisé)| Sur de nombreux clusters HPC utilisant Guix, ce canal peut déjà être configuré globalement par les administrateurs. C’est le cas sur cluster IO`. Vérifiez la documentation locale ou demandez. Si vous devez le faire vous-même : |
1 Éditez (ou créez) le fichier ~/.config/guix/channels.scm.
2 Ajoutez l’entrée pour guix-hpc (et d’autres si besoin).
channels.scm incluant guix et guix-hpc;; ~/.config/guix/channels.scm (list ;; Canal officiel GNU Guix (Indispensable) (channel (name 'guix) (url "https://git.savannah.gnu.org/git/guix.git") ;; Optionnel: décommentez et mettez un commit précis pour figer la version de Guix ;; (commit "<commit_hash_guix>") ) ;; Canal Guix-HPC (Très recommandé pour le calcul scientifique) (channel (name 'guix-hpc) (url "https://github.com/guix-hpc/guix-hpc.git") ;; Optionnel: figer la version du canal HPC ;; (commit "<commit_hash_guix_hpc>") ) ;; Exemple: Ajouter un canal pour la bioinformatique (si besoin) ;; (channel ;; (name 'guix-bioinfo) ;; (url "https://github.com/guix-bioconda/guix-bioinfo") ;; ) )
3 Lancez guix pull. Cette commande va maintenant télécharger les définitions de paquets depuis tous les canaux listés. Cela peut prendre un certain temps la première fois.
Une fois guix pull terminé, les paquets des nouveaux canaux sont disponibles via guix search, guix install, guix shell et dans les manifestes.
Les noms des paquets HPC peuvent être plus spécifiques pour distinguer les variantes (ex: openmpi-gcc vs openmpi-intel, hdf5-serial vs hdf5-parallel). Utilisez guix search !
|
# Chercher les variantes d'OpenMPI guix search openmpi # Voir les détails d'une version spécifique (nom trouvé via search) # Supposons qu'il existe un paquet nommé 'openmpi-ucx' guix show openmpi-ucx # Créer un environnement temporaire avec OpenMPI et HDF5 parallèle # Remplacer par les noms exacts trouvés sur votre système ! guix shell openmpi-ucx hdf5-parallel -- bash # Dans le nouveau shell: # Vérifier la version MPI et les chemins which mpicc mpicc --showme:version # Vérifier si un wrapper HDF5 parallèle est disponible which h5pcc # Ou un nom similaire # Quitter l'environnement exit # Utiliser ces paquets dans un manifeste manifest_hpc.scm # Créez d'abord le fichier manifest_hpc.scm : # ---- manifest_hpc.scm ---- # (use-modules (guix packages) (gnu packages ...) (hpc packages ...)) ; Adapter les modules! # (specifications->manifest # (list # "openmpi-ucx" ; Nom exact du paquet MPI # "hdf5-parallel" ; Nom exact du paquet HDF5 parallèle # "gcc-toolchain" ; Pour compiler # "make" # )) # ---- fin manifest_hpc.scm ---- # Puis utiliser le manifeste pour compiler : # guix shell -m manifest_hpc.scm -- make my_mpi_hdf5_program
En combinant un manifeste (manifest.scm) qui liste tous vos paquets (y compris ceux de guix-hpc) et un fichier channels.scm qui spécifie les commits exacts des canaux utilisés (décommentez les lignes commit), vous pouvez garantir une reproductibilité bit pour bit de votre environnement logiciel. C’est l’objectif ultime pour de nombreuses simulations scientifiques. Vous pouvez partager ces deux fichiers avec votre code source.
Comment faire pour que vos jobs SLURM bénéficient des environnements Guix ? C’est très simple : vous utilisez guix shell à l’intérieur de votre script sbatch.
Le Principe : Le script SLURM demande les ressources matérielles (CPU, mémoire, temps, GPU…). Puis, avant de lancer votre code scientifique, il invoque guix shell (soit directement avec la liste des paquets, soit via un manifeste) pour mettre en place l’environnement logiciel requis. Votre code s’exécute alors dans cet environnement Guix temporaire, isolé et reproductible, sur le nœud de calcul alloué.
guix shell <paquets> — <commande> dans SLURMSimple pour des environnements avec peu de paquets ou des scripts courts.
guix shell#!/bin/bash #SBATCH --job-name=GuixPySlurm #SBATCH --output=guix_py_%j.out #SBATCH --error=guix_py_%j.err #SBATCH --time=00:10:00 #SBATCH --nodes=1 #SBATCH --ntasks=1 #SBATCH --cpus-per-task=1 #SBATCH --mem=1G # --- Configuration --- # Le script python à exécuter (supposé être dans le dossier de soumission) PYTHON_SCRIPT="$SLURM_SUBMIT_DIR/mon_script_numpy.py" INPUT_DATA="$SLURM_SUBMIT_DIR/input.dat" # --- Pré-requis Guix --- # IMPORTANT: Assurez-vous que l'environnement Guix est accessible sur les noeuds de calcul. # Cette ligne dépend de l'installation du cluster. Demandez aux admins. # Exemple possible (ADAPTER !) : # source /etc/profile.d/guix.sh # Ou $HOME/.guix-profile/etc/profile echo "--- Lancement du Job SLURM avec Guix ---" echo "Date: $(date)" echo "Noeud: $(hostname)" echo "Job ID: $SLURM_JOB_ID" echo "Lancement de $PYTHON_SCRIPT via 'guix shell python python-numpy ...'" echo "---------------------------------------" # Vérifier si le script Python existe if [ ! -f "$PYTHON_SCRIPT" ]; then echo "ERREUR: Script $PYTHON_SCRIPT non trouvé dans $SLURM_SUBMIT_DIR !" exit 1 fi # Vérifier si les données d'entrée existent if [ ! -f "$INPUT_DATA" ]; then echo "ERREUR: Fichier d'entrée $INPUT_DATA non trouvé !" exit 1 fi # Lancer la commande python DANS un environnement Guix temporaire # Le '--' sépare les options de guix shell de la commande à exécuter guix shell python python-numpy -- \ python "$PYTHON_SCRIPT" --input "$INPUT_DATA" # Passer les arguments au script Python STATUS=$? # Récupérer le code de retour de la commande 'python ...' echo "---------------------------------------" if [ $STATUS -ne 0 ]; then echo "ERREUR: Le script Python a échoué avec le code $STATUS" exit $STATUS else echo "Script Python terminé avec succès." fi echo "--- Fin du Job SLURM ---"
(Nécessite un script mon_script_numpy.py qui utilise numpy et un fichier input.dat dans le répertoire de soumission).
guix shell -m …) dans SLURM (Recommandé)Plus propre, plus gérable et plus reproductible pour des environnements complexes.
guix shell -m manifest.scm pour un code MPI#!/bin/bash #SBATCH --job-name=GuixManifestSlurm #SBATCH --output=guix_manifest_%j.out #SBATCH --error=guix_manifest_%j.err #SBATCH --time=01:00:00 # Plus de temps pour compiler/exécuter potentiellement #SBATCH --nodes=2 # Exemple MPI sur 2 noeuds #SBATCH --ntasks-per-node=8 # 8 processus MPI par noeud (total 16) #SBATCH --cpus-per-task=1 #SBATCH --mem=4G # --- Configuration --- # Le manifeste décrivant l'environnement (paquets MPI, HDF5, compilateur...) # Supposé être dans le dossier de soumission MANIFEST_FILE="$SLURM_SUBMIT_DIR/hpc_env_manifest.scm" # L'exécutable MPI (supposé déjà compilé ou compilé dans le job) EXECUTABLE_PATH="$SLURM_SUBMIT_DIR/mon_executable_mpi" # Fichier de paramètres pour l'exécutable PARAMS_FILE="$SLURM_SUBMIT_DIR/params.txt" # --- Pré-requis Guix --- # Activer l'environnement Guix (adapter si besoin) # source /etc/profile.d/guix.sh echo "--- Lancement Job SLURM avec Manifeste Guix ---" echo "Date: $(date)" echo "Job ID: $SLURM_JOB_ID" echo "Manifeste: $MANIFEST_FILE" # Vérifier si le manifeste et l'exécutable existent if [ ! -f "$MANIFEST_FILE" ]; then echo "ERREUR: Manifeste $MANIFEST_FILE non trouvé!" exit 1 fi if [ ! -x "$EXECUTABLE_PATH" ]; then echo "ERREUR: Exécutable $EXECUTABLE_PATH non trouvé ou non exécutable!" # Alternative: compiler ici DANS l'environnement guix shell # echo "Tentative de compilation..." # guix shell -m "$MANIFEST_FILE" -- make # Si un Makefile existe dans $SLURM_SUBMIT_DIR # if [ ! -x "$EXECUTABLE_PATH" ]; then echo "Echec compilation"; exit 1; fi exit 1 fi if [ ! -f "$PARAMS_FILE" ]; then echo "WARNING: Fichier paramètres $PARAMS_FILE non trouvé." fi echo "Lancement de srun via 'guix shell -m ... -- srun ...'" echo "---------------------------------------------" # Lancer srun (pour MPI) DANS l'environnement créé par guix shell via le manifeste # Le manifeste doit contenir 'openmpi' (ou autre MPI) et les dépendances d'exécution guix shell -m "$MANIFEST_FILE" -- \ srun "$EXECUTABLE_PATH" --input "$PARAMS_FILE" STATUS=$? # Code retour de srun (ou de l'exécutable MPI si srun le propage bien) echo "---------------------------------------------" if [ $STATUS -ne 0 ]; then echo "ERREUR: srun/executable a échoué avec le code $STATUS" exit $STATUS else echo "Exécution terminée avec succès." fi echo "--- Fin du Job SLURM ---"
(Nécessite un fichier hpc_env_manifest.scm contenant au moins openmpi et les dépendances d’exécution, un exécutable mon_executable_mpi, et optionnellement params.txt).
Avantage Clé dans SLURM : Chaque nœud de calcul alloué par SLURM exécute le guix shell indépendamment mais de manière identique (grâce à la nature fonctionnelle de Guix). Cela garantit que l’environnement logiciel est strictement le même sur tous les nœuds participant au job, éliminant une source majeure de problèmes en calcul parallèle.
Guix représente une approche puissante et différente de la gestion des logiciels, particulièrement adaptée aux exigences de reproductibilité et de complexité du HPC.
Récapitulatif :
Guix garantit la reproductibilité grâce à son approche fonctionnelle et son magasin (/gnu/store) immuable.
Il offre un contrôle fin à l’utilisateur via les profils et les environnements temporaires/manifestes.
guix shell et les manifestes (.scm) sont les outils clés pour créer des environnements isolés et partageables.
Le canal guix-hpc (et d’autres) fournit les outils spécifiques au calcul scientifique.
L’intégration avec SLURM se fait simplement en lançant guix shell […] — <votre commande> dans vos scripts sbatch.
Avantages Clés pour Vous en HPC :
Fini les soucis de versions de bibliothèques conflictuelles.
Confiance accrue dans la reproductibilité de vos résultats.
Facilité de partage d’environnements logiciels complexes avec des collaborateurs.
Autonomie dans la gestion de vos dépendances logicielles.
Prochaines Étapes (Pour aller plus loin) :
Maîtriser les Manifestes : Apprendre un peu plus de Scheme pour des manifestes plus complexes (transformations de paquets, utilisation de package→manifest…).
Créer vos Propres Paquets : Contribuer à Guix ou définir des paquets pour vos propres logiciels ou des versions spécifiques non disponibles.
Explorer d’autres Canaux : Chercher des canaux pour des domaines spécifiques (bioinfo, IA, etc.). Consulter https://guix.gnu.org/en/channels/registry/.
Guix et Conteneurs : Utiliser guix pack (https://guix.gnu.org/manual/en/html_node/Invoking-guix-pack.html) pour créer des images Docker ou Singularity/Apptainer à partir de votre environnement Guix (pour partager avec des non-utilisateurs de Guix).
Guix System : Explorer l’utilisation de Guix pour gérer l’intégralité d’un système d’exploitation (plus avancé, souvent pour des machines personnelles ou des VM dédiées).
Guix a une courbe d’apprentissage initiale (notamment la syntaxe Scheme), mais l’investissement en vaut la peine pour la robustesse, la flexibilité et la reproductibilité qu’il apporte à vos travaux de recherche. Explorez, testez avec guix shell, et profitez de la puissance des environnements reproductibles !
| Commande | Description |
|---|---|
|
Met à jour Guix lui-même et télécharge les dernières définitions depuis les canaux configurés ( |
|
Recherche des paquets disponibles par nom ou description. |
|
Affiche les informations détaillées sur un paquet (version, dépendances, etc.). |
|
Installe un paquet dans le profil par défaut (ajoute des liens symboliques). Crée une nouvelle génération de profil. |
|
Supprime un paquet du profil par défaut (enlève les liens). Crée une nouvelle génération de profil. |
|
Met à jour tous les paquets du profil par défaut vers les dernières versions disponibles via |
|
Liste les paquets installés dans le profil courant. |
|
Liste les générations précédentes du profil courant. |
|
Active la génération N du profil. Permet le rollback. |
|
Supprime les anciennes générations du profil. |
|
Exécute |
|
Ouvre un shell interactif dans un environnement temporaire contenant les |
|
Utilise un fichier manifeste pour définir l'environnement temporaire. |
|
Affiche les informations sur la génération courante de Guix et ses canaux (utile pour la reproductibilité). |
|
Lance le ramasse-miettes (garbage collector) pour supprimer les éléments du |