Guide d’installation des applications

L’équipe HPC-MARWAN prend en charge l’installation d’une pile logicielle assez étendue d’outils et d’applications les plus couramment utilisés par la communauté scientifique marocaine. Cependant, il est recommandé aux utilisateurs d’installer eux-mêmes les applications spécifiques dont dépend leur travail.

La liste des applications installées sur HPC-MARWAN sont disponibles sur le site web HPC-MARWAN , ou en utilisant la commande « module avail ». Pour plus d’information, voir le guide d’utilisateur lien.

Indépendamment de la méthode d’installation, le répertoire d’application doit être placer dans l’espace utilisateur /home/$USER. Si l’installations ne peut être effectuée que par l’équipe HPC-MARWAN. Vous pouvez envoyer une demande d’installation d’application à l’équipe par mail à hpc@marwan.ma Ceci est un d’installation des applications dans votre répertoire personnel. Si vous avez besoin d’aide, veuillez envoyer vos erreurs via mail à hpc@marwan.ma.

Condition d’installation

  • Vérifiez si l’application est déjà disponible dans le cluster HPC-MARWAN en utilisant les commandes « module spider » ou « module avail ».

  • Les binaires, bibliothèques et fichiers d’inclusion du système sont situés dans /usr/bin/, /usr/lib/ , /usr/lib64 et /usr/include.

  • Si l’application a des dépendances d’installation - telles que des bibliothèques, des interfaces ou des modules - vérifiez d’abord si elles sont déjà fournies sur le cluster avant de les installer vous-même. Assurez-vous d’avoir d’abord chargé (module load) le compilateur, le langage interprété ou l’application concernés avant d’examiner la liste des logiciels fournis, car cette liste est ajustée dynamiquement en fonction de votre environnement actuel.

  • L’application ne peut pas être installé directement via les RPMs/YUM. elle doit être téléchargée sous forme de fichier compressé, par exemple tar.gz.

  • Red Hat Entreprise Linux 8 est notre système d’exploitation par défaut.

Préparations d’installation

Dossier d’installation

La partie la plus importante de l’installation d’une application est d’identifier où vous devez l’installer et comment vous devez modifier le script d’installation pour pointer vers le bon emplacement. Nous recommandons la structure de répertoire suivante, que vous devez créer au niveau supérieur de votre répertoire personnel :

local
    |-- apps
    |-- modfiles
    |-- share
  • local/apps - Rassemble tous les fichiers liés à vos installations locales dans un seul répertoire, pour éviter d’encombrer votre répertoire personnel. Les applications seront installées dans ce répertoire avec le format « nom d’application/version ». Cela vous permet de gérer facilement plusieurs versions d’une installation logicielle particulière si nécessaire.

  • local/share - Stocke les installateurs - généralement les répertoires sources - de vos applications. Stocke également les archives compressées (« tarballs ») de vos installateurs ; utile si vous voulez réinstaller plus tard en utilisant différentes options de construction.

  • local/modfiles – le dossier standard pour stocker les fichiers de modules, qui vous permettront d’ajouter ou de supprimer dynamiquement des applications installées localement dans votre environnement.

Vous pouvez créer cette structure avec une seule commande :

$  mkdir -p /home/$USER/local/apps /home/$USER/local/modfiles/home/$USER/local/share

Allocation de ressource

Ne lancer pas l’installation de l’application directement sur des nœuds de connexion (login), car ceci peut avoir un impact sur les sessions et la connectivité de tous les autres membres du cluster. Réserver un nœud de calcul, en exécutant la commande suivante :

$ salloc -N 1 -n 1 -p defq bash
$ ssh nodealocated

Certains paquets permettent la compilation en parallèle. Pour compiler en parallèle, vous aurez besoin de plus de tâches. Choisissez une valeur différente pour l’indicateur -n. Il s’agira du nombre de threads que vous pourrez spécifier à la compilation.

Téléchargement de l’application

Maintenant que vous avez créé votre structure de répertoire, vous pouvez installer votre application. Pour les besoins de la démonstration. Tout d’abord, localisez le fichier d’installation dans le site web qui correspond à l’environnement et à la plate-forme de votre serveur. Les fichiers d’installation sont généralement au format de compression tar.gz, tar.bz2. Téléchargez le fichier d’installation dans votre répertoire personnel $HOME/local/share :

$ cd $HOME/local/share

Depuis le web :

$ wget <url>

(Cliquez avec le bouton droit de la souris sur le lien du fichier et sélectionnez « copier l’adresse du lien » pour l’url).

Depuis GitHub : comme un service d’hébergement basé sur le web, clonez le dépôt ou vous pouvez télécharger le format .zip en cliquant sur le lien ZIP :

$ git clone <url>

(Remarque : s’il n’y a pas d’option wget ou git pour télécharger et que vous téléchargez le fichier manuellement sur votre PC, transférez-le au HPC en suivant la procédure suivante :

$ scp -r /fromyourlocal/folder-name   $USER@hpc-login.marwan.ma:/home/$USER/local/share/

Installation d’application

From source code

Maintenant que vous avez créé votre structure de répertoire, et téléchargée le code source de l’application, vous pouvez installer votre application.

Tout d’abord, vous devez décompresser l’archive afin d’avoir accès au code source et aux autres fichiers :

$ tar xzvf software-name-0.1.tar.gz

Ensuite, nous allons aller dans le répertoire source.

$ cd  software-name-0.1

Vous pouvez trouver les fichiers README, Notes ou INSTALL avec d’autres fichiers de configuration. Ces fichiers peuvent vous guider dans votre processus d’installation. Si vous trouvez CMakeLists.txt, alors vous devez l’installer en utilisant l’utilitaire cmake. Si vous trouvez le fichier configure, alors vous allez suivre le process « Configure-Make-MakeInstall ».

Configure-Make-MakeInstall

Dans ce cas, nous utiliserons l’option –prefix de l’outil configure pour spécifier l’emplacement d’installation.

$./configure --prefix=/home/$USER/local/apps/software-name/version
$ make
$ make install
$ make clean

configure est généralement un script shell complexe qui rassemble des informations sur le système et prépare le processus de compilation. Avec l’option –prefix vous pouvez spécifier un répertoire d’installation de base, où make install installera les fichiers dans des sous-répertoires comme bin, lib, include, etc. L’utilitaire make est celui qui effectue la compilation et l’édition de liens. Si, par exemple, certaines bibliothèques supplémentaires manquent sur le système ou ne sont pas trouvées à l’endroit prévu, la commande se terminera immédiatement.

CMake install

Cmake est le système de construction multiplateforme. Le processus de construction est décrit dans un simple fichier texte CMakeLists.txt via des commandes spéciales de CMake. Lorsqu’il est invoqué, CMake analyse ces fichiers texte et génère une chaîne de compilation native pour la plate-forme et le compilateur souhaités. Il fournit des options permettant à l’utilisateur de personnaliser le processus de construction. Pour modifier les variables CMake, utilisez l’option -D après la commande cmake. Pour changer l’emplacement du répertoire d’installation du répertoire par défaut /usr/local au répertoire personnel, utilisez « DCMAKE_INSTALL_PREFIX=/home/$USER/local/apps/software-name/version ». Créez un répertoire de build et accédez-y. Les résultats du compilateur sont stockés ici, ce qui inclut les fichiers objets ainsi que l’exécutable final et les bibliothèques.

$mkdir /home/$USER/local/sahre/software-name-0.1/build;cd build

Exécutez la commande cmake avec les options appropriées.

$cmake .. -DCMAKE_INSTALL_PREFIX=/home/$USER/local/apps/software-name/version

(Si vous devez assigner plusieurs bibliothèques, vous pouvez le faire avec -D<X_LIBRARIES>=”-L <path-to-library> -l<lib1> -l<lib2>”)

Makefile est créé dans le répertoire source une fois la configuration terminée. Maintenant, vous pouvez lancer la commande make :

$make

Pour installer les binaires et les bibliothèques à l’emplacement préfixé par configure pour le logiciel installé, utilisez la commande make install.

$make install

Votre application devrait maintenant être complètement installée. Cependant, avant de pouvoir l’utiliser, vous devrez ajouter les répertoires de l’installation à votre chemin. Pour ce faire, vous devrez créer un module.

Precompiled Binaries

Dans ce cas, Il vous suffit de décompresser ou de dé-tarer le fichier d’installation en déterminant le chemin dans le module file.

$tar xzvf software-name-0.1.tar.gz -C /home/$USER/local/apps/software-name/version
$unzip software-name-0.1.zip  -d /home/$USER/local/apps/software-name/version

Il y a des cas où le répertoire bin peut ne pas avoir la permission d’exécuter. Dans ce cas, exécutez la commande suivante :

$chmod -R 755 <path-to-bin>/bin

Easybuild

EasyBuild est un logiciel de build et d’installation d’application visant spécifiquement les systèmes HPC, avec un accent sur l’automatisation du build, la reproductibilité et la résolution automatique des dépendances. Il est entièrement compatible avec le système de modules Lmod, et chaque installation d’EB génère automatiquement un fichier module correspondant qui vous permet de charger le logiciel dans votre environnement. EasyBuild est le moyen le plus simple et le plus rapide pour installer une application par vous-même. Toutes les installations sont effectuées au niveau de l’utilisateur, vous n’avez donc pas besoin des droits d’administrateur (root). Les applications sont installés dans votre répertoire personnel sous $EASYBUILD_PREFIX.

$mkdir -p /home/$USER/local/Easybuild
$Export $ EASYBUILD_PREFIX=/home/$USER/local/Easybuild

Les logiciels installée sont placés sous ${EASYBUILD_PREFIX}/software/ Le chemin d’installation des modules ${EASYBUILD_PREFIX}/modules/all

Afin d’installer une application en utilisant Easybuild, Les étapes suivantes sont nécessaires :

  • Charger les modules

  • Trouver la spécification du package

  • Déterminer la chaine d’outil souhaitée

  • Lancer l’installation EasyBuild en utilisant eb-install-all ou eb-install-generic

Charger les modules

En premier lieu, vous devez charger le module EasyBuild. Assurez-vous que vous avez un environnement propre sans aucun autre module chargé :

$module purge
$module load EasyBuild

Rappelons que vous devez être sur un nœud de calcul pour poursuivre vos installation.

Chercher le package

EasyBuild dispose d’un large référentiel d’application disponibles en différentes versions. Les applications disponibles peuvent être recherchés en utilisant la commande suivante :

$eb -S software-name

Easybuild génère la liste des référentiels. Dans cette liste, vous devez sélectionner la version correspondante à la version de la chaîne d’outils cible, exemple «softwarename3.8-GCCcore-9.3.0-Java-1.8.eb» .

Choisir le package

Pour installer une application avec EasyBuild, la première chose à faire est de choisir une chaîne d’outils de compilation supportée par EasyBuild. Cette chaine d’outils spécifie les dépendances associées, qui sont chargées avec l’application. Ces dépendances peuvent avoir d’autres dépendances.

Les chaînes d’outils de compilation sont essentiellement un ensemble de compilateurs avec un ensemble de bibliothèques qui fournissent un support supplémentaire qui est généralement requis pour construire des logiciels. Cela consiste généralement en une bibliothèque MPI (communication inter-processus sur un réseau), BLAS/LAPACK (routines d’algèbre linéaire) et FFT (Transformations de Fourier rapides).

La chaîne de dépendances est appelée toolchain. Par exemple :

  • GCC consiste en GCCcore et binutils

  • gompi consiste en GCC et OpenMPI

  • foss est basé sur le compilateur GCC et sur des bibliothèques open-source (OpenMPI, OpenBLAS, FFTW, ScaLAPACK etc.).

  • intel est basé sur le compilateur Intel et sur des bibliothèques Intel (Intel MPI, Intel Math Kernel Library, etc.).

Pour lister les toolchains connues d’EasyBuild, utilisez l’option de ligne de commande –list-toolchains (disponible depuis EasyBuild v1.1). Cela donnera quelque chose comme ci-dessous :

$ eb --list-toolchains
List of known toolchains (toolchainname: module[,module...]):
        ClangGCC: Clang, GCC
        GCC: GCC
        cgmpich: ClangGCC, MPICH
        cgmpolf: BLACS, ClangGCC, FFTW, MPICH, OpenBLAS, ScaLAPACK
        cgmvapich2: ClangGCC, MVAPICH2
        cgmvolf: BLACS, ClangGCC, FFTW, MVAPICH2, OpenBLAS, ScaLAPACK
        cgompi: ClangGCC, OpenMPI
        cgoolf: BLACS, ClangGCC, FFTW, OpenBLAS, OpenMPI, ScaLAPACK
        dummy:
        gcccuda: CUDA, GCC
        gimkl: GCC, imkl, impi
        gmacml: ACML, BLACS, FFTW, GCC, MVAPICH2, ScaLAPACK
        gmpich2: GCC, MPICH2
        gmpolf: BLACS, FFTW, GCC, MPICH2, OpenBLAS, ScaLAPACK
        gmvapich2: GCC, MVAPICH2
        gmvolf: BLACS, FFTW, GCC, MVAPICH2, OpenBLAS, ScaLAPACK
        goalf: ATLAS, BLACS, FFTW, GCC, OpenMPI, ScaLAPACK
        gompi: GCC, OpenMPI
        goolf: BLACS, FFTW, GCC, OpenBLAS, OpenMPI, ScaLAPACK
        goolfc: BLACS, CUDA, FFTW, GCC, OpenBLAS, OpenMPI, ScaLAPACK
        gqacml: ACML, BLACS, FFTW, GCC, QLogicMPI, ScaLAPACK
        iccifort: icc, ifort
        ictce: icc, ifort, imkl, impi
        iiqmpi: QLogicMPI, icc, ifort
        iomkl: OpenMPI, icc, ifort, imkl
        iqacml: ACML, BLACS, FFTW, QLogicMPI, ScaLAPACK, icc, ifort
        ismkl: MPICH2, icc, ifort, imkl

Installation

Après avoir sélectionné le package d’installation et toolchain cible, le processus d’installation peut être soumis. Les packages y sont installés et les fichiers de modules créés. La syntaxe générale est la suivante :

$ eb_install_{all,generic} [options] [easybuild options] <software-name-toolchain>.eb

Example d’installation de Geant4:

$ export tmp_dir=/home/$USER/_Easybuild/tmp
$ export source_path=/home/$USER/local/share
$eb Geant4-10.5-foss-2018b.eb -r --tmpdir=$tmp_dir --ignore-checksums --sourcepath=$source_path

Dans cet exemple on lance l’installation de l’application Geant4 version 10.5 dont le toolchain est « foss-2018b ». L’option -r (–robot) active la résolution des dépendances, en installant automatiquement toutes les dépendances. L’option –sourcepath permet de déterminer le dossier dans lequel Easybuild télécharge les archives et procède à l’installation, par contre l’option –tmpdir definit le dossier temporaire de chargement des archives. Pour plus de détails merci de consulter le site officiel de easybuild : https://docs.easybuild.io/en/latest/Configuration.html

Une fois terminé, un message comme celui-ci s’affiche : .. code-block:: bash

== Build succeeded for 1 out of 1 == Temporary log file(s) /tmp/eb-BoOCuj/easybuild-CuSy5M.log* have been removed. == Temporary directory /tmp/eb-BoOCuj has been removed.

vous devriez être en mesure d’utiliser l’application, en chargeant simplement le module du package installé :

$ module use /home/$USER/local/Easybuild/all
$ module load  software-name

Création de module

Après avoir installé l’application dans votre répertoire comme expliqué ci-dessus, et avant de l’utiliser, un fichier module utilisateur doit être créé. Un fichier module décrit l’emplacement et la configuration de l’environnement pour l’application ciblée, par exemple en définissant les variables PATH, LD_LIBRARY_PATH et autres. Le système Lmod actuel recherche ces fichiers modules dans les sous-répertoires de tous les répertoires enregistrés dans $MODULEPATH. Supposons que nous avons installé l’application software-name avec la version « X.Y». Le répertoire de module serait alors : .. code-block:: bash /home/$USER/local/modfiles/software-name/toolchaine/X.Y Nommez le fichier de module comme le numéro de version (X.Y) de votre logiciel installé, puis placez le fichier de module dans un répertoire portant le nom du logiciel. La manière la plus simple d’écrire votre fichier de module est d’utiliser l’exemple ci-dessous comme modèle.

#%Module -*- tcl -*-
###
### dot modulefile
###
proc ModulesHelp { } {
  puts stderr "\tAdds software-name to your environment variables,"
  }
  module-whatis "adds software-name to your environment variables"
 set                       version                     $version
 set                       root                          /home/$USER/local/apps/software-name
 prepend-path     PATH                        $root/bin
 prepend-path     LD_LIBRARY_PATH   $root/lib64
 prepend-path     LIBRARY_PATH         $root/lib64
 prepend-path     CPATH                      $root/include

Afin d’utiliser ce module, vous devez indiquer à lmod où le chercher. Vous pouvez le faire en lançant la commande module use :

$ module use /home/$USER/local/modfiles
$ module load software-name/toolchaine/version

NOTE : le module use et le module load « software_name » doivent être entrés dans la ligne de commande chaque fois que vous entrez dans une nouvelle session sur le système, aussi à déclarer au niveau du script Slurm pour lancer un job utilisant une de vos applications installées en local.