Gestion des noyaux

Noyaux disponibles

Pour les langages Julia, Golang, R et C++/ROOT, des noyaux prêts à l’emploi sont disponibles à l’emplacement suivant :

/pbs/software/centos-7-x86_64/jupyter_kernels/

Afin de les rendre disponible dans votre serveur de notebook, il suffit de copier le répertoire du noyau désiré (ici Golang v1.13.6) dans l’emplacement dédié de son répertoire utilisateur $HOME/.local/share/jupyter/kernels/ :

% mkdir -p $HOME/.local/share/jupyter/kernels/  # Si ce répertoire n'existe pas encore

% cp -r /pbs/software/centos-7-x86_64/jupyter_kernels/Golang-1.13.6 $HOME/.local/share/jupyter/kernels/.

Ajouter un noyau personnalisé

Pour ajouter un noyau personnalisé, il faut fournir à Jupyter un fichier de configuration approprié. Ce fichier de configuration fera appel à un environnement virtuel Python ou Anaconda nécessitant les dépendances suivantes :

ipykernel, pyzmq et zeromq pour tout noyau :
- ipykernel dépend de pyzmq qui dépend de zeromq.
dask4in2p3 quand utilisant la fonctionnalité Dask.

Important

L’environnement du noyau Python doit être auto-suffisant, c’est à dire l’ensemble des modules Python requis doit être disponible dans l’environnement. Voir l’exemple du jupyter-helper.sh ci-dessous.

Une fois que votre environnement virtuel est configuré, veuillez suivre les étapes suivantes pour préparer un noyau personnalisé :

Créez un nouveau répertoire dans $HOME/.local/share/jupyter/kernels/, disons python-3.9 (dans cet exemple nous voulons ajouter un noyau personnalisé Python 3.9)

Si l’arborescence des répertoires n’existe pas encore, vous devez la créer.
```
% mkdir -p $HOME/.local/share/jupyter/kernels/python-3.9
```
Allez dans ce répertoire et créez un fichier kernel.json qui ressemblera à ceci :
```
{
  "display_name": "conda3",
  "language": "python",
  "argv": [
      "<CHEMIN DU SCRIPT>/jupyter-helper.sh",
      "-f",
      "{connection_file}"
  ]
}
```
display_name est le nom que vous souhaitez donner à votre noyau personnalisé et sera affiché dans votre instance JupyterLab. Vous pouvez également mettre à jour le paramètre language. Mais la partie la plus importante est le script jupyter-helper.sh.

Alternativement, vous pouvez exécuter la ligne suivante :

% python -m ipykernel install --user --name python-3.9 --display-name "Python (python-3.9)"

Cela créera un fichier ~/.local/share/jupyter/kernels/python-3.9/kernel.json qui ressemblera à :

{
  "argv": [
    "/work/scratch/env/$USER/.conda/envs/NAME/bin/python",
    "-m",
    "ipykernel_launcher",
    "-f",
    "{connection_file}"
  ],
  "display_name": "Python (python-3.9)",
  "language": "python",
  "metadata": {
    "debugger": true
  }
}

Le script jupyter-helper.sh fournira les détails pour configurer l’environnement du nouveau noyau. Ce script ressemblera à ceci :
```
#!/bin/bash
source /usr/share/Modules/init/bash

module load Programming_Languages/anaconda/3.9
conda activate your_env

unset PYTHONPATH
export PYTHONPATH=/path/to/your_env:$PYTHONPATH

exec python -m ipykernel_launcher "$@"
```
La première partie configure l’environnement requis (ici, nous mettons en place l’environnement Anaconda your_env), et la dernière ligne indique à Jupyter comment démarrer ce nouveau noyau. Pour que le noyau puisse s’initialiser il faut que le script ait les permissions d’exécution :
```
% chmod +x jupyter-helper.sh
```

Note

Le CC-IN2P3 fournit le script jupyter-helper.sh pour configurer des noyaux personnalisés, par exemple pour les plus récents environnements ROOT ou Python déjà fournis dans notre zone logicielle. La liste complète des scripts disponibles se trouve dans le fichier suivant :

/pbs/software/centos-7-x86_64/jupyter_kernels/jupyter_helper_scripts

Environnement python pour GPU

Dans la recette suivante nous décrirons l’installation de JAX comme exemple.

Se connecter à un serveur de notebook associé à une GPU, afin d’avoir CUDA installé. Ouvrir une nouvelle fenêtre de terminal.

Charger une version récente de python :

% module load Programming_Languages/python/3.9.1

Créer un environnement virtuel python (jax_env for this example).
Installer la librairie python basé sur CUDA, et d’autres paquets si nécessaire. Ici nous installerons simplement JAX. Pour ce faire choisir le paquet correspondant à CUDA 11.4 et, de conséquence, le cudnn compatible.
```
% python -m pip install "jax[cuda11_cudnn805]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html --prefix=/path/to/jax_env
```
```
% python -m pip install "jax[cuda11_cudnn805]"  "jaxlib[cuda11_cudnn805]"
```
Attention

Les fonctionnalités GPU sur la plateforme Jupyter sont limités par rapport à la plateforme de calcul. Ce qui peut être exécuté dans un job, ne pourra pas toujours s’exécuter sur la plateforme.
Tester que le paquet est bien installé et que le device GPU est bien trouvé :
```
% python -c "import jax; print(jax.devices())"
```
Créer un noyau personnalisé avec cet environnement comme décrit plus haut.