Apptainer est un outil de conteneurisation qui permet d'exécuter des applications dans des environnements logiciels isolés, appelés conteneurs. Il suit la même logique que Docker, mais il est adapté aux infrastructures de calcul. Sur la plateforme, il permet d'installer soi-même des outils et des bibliothèques et de les utiliser sur les nœuds de calcul, sans intervention de l'administrateur.

Exemple utilisé sur cette page : faire tourner un programme C qui utilise la bibliothèque OpenBLAS, qui n'est pas installée sur les nœuds de calcul.

Tout se fait directement sur le frontal frontalhpc2025.

ssh login@frontalhpc2025

Vous arrivez dans votre répertoire personnel. Toutes les commandes de ce tuto se lancent depuis cet endroit.

Ce répertoire servira à ranger vos fichiers de définition et vos images.

mkdir APPTAINER
cd APPTAINER

Le fichier .def est la « recette » du conteneur : un système de base, plus les logiciels à installer.

Dans le répertoire APPTAINER, créez le fichier openblas.def avec ce contenu :

Bootstrap: docker
From: ubuntu:24.04

%post
    apt-get update -y
    apt-get install -y gcc libopenblas-dev

Pour installer d'autres logiciels, ajoutez simplement leurs paquets Ubuntu à la ligne apt-get install.

Remarque. Si votre logiciel n'existe pas dans le repo d'ubuntu et doit être compilé à la main, voir la section "pour aller plus loin" en bas de cette page.

Depuis votre répertoire APPTAINER :

apptainer build --fakeroot openblas.sif openblas.def

La construction prend quelques minutes. Elle produit le fichier openblas.sif : c'est votre image.

Le principe : on préfixe chaque commande par apptainer exec openblas.sif. La commande s'exécute alors dans le conteneur.

Exemple : on crée un petit code C qui utilise Openblas (donné en bas de page) : enregistrez-le sous le nom mon_code.c.

Compilez-le en utilisant votre image (il suffit donc de préfixer gcc par apptainer exec openblas.sif)

apptainer exec openblas.sif gcc -o mon_exe mon_code.c -lopenblas

Créez le script mon_job.sh :

#!/bin/bash
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=1
 
apptainer exec openblas.sif ./mon_exe

Soumettez le job :

sbatch mon_job.sh

Ensuite tout se déroule comme pour un job classique.

C'est tout ! La suite de la page est facultative.

Un fichier .def contient plusieurs sections :

• Bootstrap / From : l'image de départ. Ici docker / ubuntu:24.04 signifie « partir de l'image Ubuntu 24.04 officielle de Docker Hub ».
• %post : les commandes exécutées une seule fois, au moment de la construction de l'image. C'est là qu'on installe les logiciels.
• %environment : les variables d'environnement définies à chaque utilisation de l'image (par exemple LD_LIBRARY_PATH).

Il y a deux manières d'installer une bibliothèque dans l'image.

C'est la version utilisée dans le tuto rapide. Elle est simple et rapide, et utilise la version d'OpenBLAS fournie par Ubuntu.

Bootstrap: docker
From: ubuntu:24.04

%post
    apt-get update -y
    apt-get install -y gcc libopenblas-dev

Les fichiers sont installés dans les répertoires standards du système (/usr/include, /usr/lib/x86_64-linux-gnu). Le compilateur les trouve tout seul : il suffit d'ajouter -lopenblas à la compilation, et aucune section %environment n'est nécessaire.

À utiliser si vous voulez contrôler précisément les options de compilation (optimisations CPU, multithread, etc.), ou si la bibliothèque dont vous avez besoin n'existe pas en paquet Ubuntu.

Bootstrap: docker
From: ubuntu:24.04

%post
    apt-get update -y
    apt-get install -y gcc make wget tar ca-certificates

    cd /tmp
    wget https://github.com/OpenMathLib/OpenBLAS/releases/download/v0.3.26/OpenBLAS-0.3.26.tar.gz
    tar xzf OpenBLAS-0.3.26.tar.gz
    cd OpenBLAS-0.3.26
    make DYNAMIC_ARCH=1
    make PREFIX=/usr/local install

%environment
    export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH

Quelques remarques :

• ca-certificates est nécessaire pour que wget puisse télécharger en HTTPS.
• DYNAMIC_ARCH=1 compile OpenBLAS pour plusieurs types de processeurs. Sans cette option, OpenBLAS est optimisé pour le processeur du frontal (là où l'image est construite), qui peut être différent de celui des nœuds de calcul.
• La bibliothèque est installée dans /usr/local, qui n'est pas un répertoire standard pour l'édition de liens dynamique : d'où la section %environment.
• La compilation depuis les sources est plus longue (de l'ordre de plusieurs dizaines de minutes).

Avec cette option, la bibliothèque n'est pas au même endroit. Pour vérifier l'image (étape 4), utilisez :

apptainer exec openblas.sif ls /usr/local/lib/libopenblas.so

Et pour compiler votre programme (étape 5), indiquez au compilateur où trouver les fichiers :

apptainer exec openblas.sif gcc -o mon_exe mon_code.c -I/usr/local/include -L/usr/local/lib -lopenblas -Wl,-rpath,/usr/local/lib

Le script Slurm ne change pas.

Le fichier .sif est une image au format SquashFS : compressée, en lecture seule et portable. Il contient un système Ubuntu complet avec GCC et OpenBLAS. Vous pouvez le copier, le partager avec un collègue ou le réutiliser pour d'autres projets.

L'option

--fakeroot''

permet de construire l'image sans être root : à l'intérieur du conteneur, pendant la construction, vous êtes vu comme root (ce qui permet apt-get install), mais pas sur le frontal.

Pour modifier l'image (ajouter un paquet, par exemple), modifiez le .def puis relancez la commande apptainer build de l'étape 4. Si le fichier .sif existe déjà, Apptainer demande confirmation avant de l'écraser.

Pendant la construction, Apptainer garde une copie des éléments téléchargés (par exemple l'image Ubuntu de base) dans un répertoire caché .apptainer/cache de votre répertoire personnel. Ce cache accélère les constructions suivantes, mais il peut devenir volumineux et compte dans votre quota.

Pour le vider :

apptainer cache clean

Vos images .sif ne sont pas touchées par cette commande.

Programme de test (multiplication de matrices), à enregistrer sous mon_code.c dans le répertoire APPTAINER :

/* mon_code.c */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <cblas.h>
 
#define N 8192
 
int main() {
    openblas_set_num_threads(1);
 
    double *A = malloc(N * N * sizeof(double));
    double *B = malloc(N * N * sizeof(double));
    double *C = calloc(N * N, sizeof(double));
 
    for (int i = 0; i < N * N; i++) {
        A[i] = (double)rand() / RAND_MAX;
        B[i] = (double)rand() / RAND_MAX;
    }
 
    struct timespec t0, t1;
    clock_gettime(CLOCK_MONOTONIC, &t0);
 
    cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,
                N, N, N, 1.0, A, N, B, N, 0.0, C, N);
 
    clock_gettime(CLOCK_MONOTONIC, &t1);
 
    double elapsed = (t1.tv_sec - t0.tv_sec) +
                     (t1.tv_nsec - t0.tv_nsec) * 1e-9;
    double gflops = (2.0 * N * N * N) / elapsed / 1e9;
 
    printf("N=%d : %.3f s | %.2f GFLOPS\n", N, elapsed, gflops);
 
    free(A); free(B); free(C);
    return 0;
}

• Documentation officielle Apptainer
• Site officiel OpenBLAS