ProHoster > Blog > Administration > Lancement de Jupyter sur l'orbite LXD

Lancement de Jupyter sur l'orbite LXD

Avez-vous dĂ©jĂ  expĂ©rimentĂ© avec le code ou des utilitaires systĂšme sous Linux sans craindre de mettre en danger votre systĂšme de base et de tout effacer en cas d'erreur dans le code devant ĂȘtre exĂ©cutĂ© avec des privilĂšges root ?

Que diriez-vous de devoir tester ou lancer un ensemble entier de microservices variĂ©s sur une seule machine ? Une centaine ou mĂȘme mille ?

Avec des machines virtuelles gĂ©rĂ©es par un hyperviseur, il est peut-ĂȘtre possible de rĂ©soudre ces tĂąches, mais Ă  quel prix ? Par exemple, un conteneur dans LXD basĂ© sur la distribution Alpine Linux consomme au minimum seulement 7.60 Mo de RAM, et oĂč la partition racine aprĂšs le dĂ©marrage occupe 9.5 Mo! Que penses-tu de cela, Elon Musk ? Je te recommande de jeter un Ɠil aux fonctionnalitĂ©s de base de LXD — un systĂšme de conteneurs sous Linux.

AprĂšs avoir compris ce que sont les conteneurs LXD, allons plus loin et imaginons une plateforme-combinaison oĂč l'on pourrait exĂ©cuter en toute sĂ©curitĂ© du code pour l'hĂŽte, gĂ©nĂ©rer des graphiques, lier dynamiquement (interactivement) les widgets de l'interface utilisateur avec votre code, ajouter du texte Ă  ce code avec du blackjack
 et de la mise en forme ? Quelque chose comme un blog interactif ? Waouh
 Je veux ! Je veux ! 🙂

Regarde sous le capot oĂč nous allons exĂ©cuter dans un conteneur JupyterLab — la prochaine gĂ©nĂ©ration d'interface utilisateur au lieu de l'obsolĂšte Jupyter Notebook, et nous allons Ă©galement installer des modules Python tels que NumPy, Pandas, Matplotlib, IPyWidgets qui permettront de rĂ©aliser tout ce qui a Ă©tĂ© mentionnĂ© ci-dessus et de tout sauvegarder dans un fichier spĂ©cial — un notebook IPython.

Lancement de Jupyter sur l'orbite LXD

Plan de lancement en orbite ^

Lancement de Jupyter sur l'orbite LXD

Établissons un bref plan d'action pour faciliter la mise en Ɠuvre du schĂ©ma ci-dessus :

  • Installons et exĂ©cutons un conteneur basĂ© sur la distribution Alpine Linux. Nous allons utiliser cette distribution car elle est axĂ©e sur la minimalisme et nous y installerons uniquement le logiciel nĂ©cessaire, rien de superflu.
  • Ajoutons un disque virtuel supplĂ©mentaire au conteneur que nous nommerons — hostfs et montons au systĂšme de fichiers racine. Ce disque permettra d'utiliser des fichiers sur l'hĂŽte depuis un rĂ©pertoire spĂ©cifiĂ© Ă  l'intĂ©rieur du conteneur. Ainsi, les donnĂ©es seront indĂ©pendantes du conteneur. En cas de suppression du conteneur, les donnĂ©es resteront sur l'hĂŽte. De plus, ce schĂ©ma est utile pour partager certaines donnĂ©es entre plusieurs conteneurs sans utiliser les mĂ©canismes rĂ©seau par dĂ©faut du distributeur de conteneurs.
  • Installons Bash, sudo, les bibliothĂšques nĂ©cessaires, ajoutons et configurons un utilisateur systĂšme.
  • Installons Python, les modules et compilons les dĂ©pendances binaires pour ceux-ci.
  • Installons et lançons. JupyterLab, configurons l'apparence et installons des extensions pour cela.

Dans cet article, nous allons commencer par lancer le conteneur, nous ne allons pas examiner l'installation et la configuration de LXD, tout cela vous pouvez le trouver dans un autre article — FonctionnalitĂ©s de base de LXD — systĂšmes de conteneurs sous Linux.

Installation et configuration du systĂšme de base ^

CrĂ©ons un conteneur avec la commande dans laquelle nous spĂ©cifions l'image — alpine3, l'identifiant pour le conteneur — jupyterlab et, si nĂ©cessaire, les profils de configuration :

lxc init alpine3 jupyterlab --profile=default --profile=hddroot

Ici, j'utilise le profil de configuration hddroot qui indique de créer un conteneur avec une partition root dans Storage Pool situé sur un disque dur physique :

lxc profile show hddroot

config: {}
description: ""
devices:
  root:
    path: \/
    pool: hddpool
    type: disk
name: hddroot
used_by: []
lxc storage show hddpool

config:
  size: 10GB
  source: /dev/loop1
  volatile.initial_source: /dev/loop1
description: ""
name: hddpool
driver: btrfs
used_by:
- /1.0/images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
- /1.0/profiles/hddroot
status: Created
locations:
- none

Cela me permet d'expĂ©rimenter avec des conteneurs sur le disque dur tout en Ă©conomisant les ressources du disque SSD qui est Ă©galement prĂ©sent dans mon systĂšme 🙂 pour lequel j'ai crĂ©Ă© un profil de configuration distinct. ssdroot.

AprÚs la création du conteneur, il se trouve dans un état STOPPED, donc nous devons le démarrer en lançant le systÚme init :

lxc start jupyterlab

Affichons la liste des conteneurs dans LXD en utilisant la clé -c qui indique quelles ccolonnes afficher à l'écran :

lxc list -c ns4b
+------------+---------+-------------------+--------------+
|    NAME    |  STATE  |       IPV4        | STORAGE POOL |
+------------+---------+-------------------+--------------+
| jupyterlab | RUNNING | 10.0.5.198 (eth0) | hddpool      |
+------------+---------+-------------------+--------------+

Lors de la crĂ©ation du conteneur, l'adresse IP a Ă©tĂ© choisie au hasard, car nous avons utilisĂ© un profil de configuration default qui a Ă©tĂ© prĂ©cĂ©demment configurĂ© dans l'article FonctionnalitĂ©s de base de LXD — systĂšmes de conteneurs sous Linux.

Nous allons changer cette adresse IP pour une plus mémorable, en créant une interface réseau au niveau du conteneur, et non au niveau du profil de configuration comme c'est le cas dans la configuration actuelle. Ce n'est pas nécessaire de le faire, vous pouvez passer cela.

CrĂ©ons une interface rĂ©seau eth0 que nous lions Ă  un commutateur (pont rĂ©seau) lxdbr0 dans lequel nous avons activĂ© NAT selon l'article prĂ©cĂ©dent, et le conteneur aura maintenant accĂšs Ă  Internet, tout en attribuant une adresse IP statique Ă  l'interface — 10.0.5.5:

lxc config device add jupyterlab eth0 nic name=eth0 nictype=bridged parent=lxdbr0 ipv4.address=10.0.5.5

AprÚs l'ajout du dispositif, il est nécessaire de redémarrer le conteneur :

lxc restart jupyterlab

VĂ©rifions l'Ă©tat du conteneur :

lxc list -c ns4b
+------------+---------+------------------+--------------+
|    NAME    |  STATE  |       IPV4       | STORAGE POOL |
+------------+---------+------------------+--------------+
| jupyterlab | RUNNING | 10.0.5.5 (eth0)  | hddpool      |
+------------+---------+------------------+--------------+

Installation des logiciels de base et configuration du systĂšme ^

Pour administrer notre conteneur, il est nécessaire d'installer le logiciel suivant :

Package
Description

bash
Le shell GNU Bourne Again

bash-completion
Complétion programmable pour le shell bash

sudo
Donner à certains utilisateurs la possibilité d'exécuter des commandes en tant que root

shadow
Suite d'outils de gestion de mots de passe et de comptes avec prise en charge des fichiers shadow et de PAM

tzdata
Sources pour le fuseau horaire et les données sur l'heure d'été

nano
Clone de l'éditeur Pico avec des améliorations

De plus, vous pouvez installer le support dans le systùme man-pages en installant les paquets suivants — man man-pages mdocml-apropos less

lxc exec jupyterlab -- apk add bash bash-completion sudo shadow tzdata nano

Examinons les commandes et les options que nous avons utilisées :

  • lxc — Appel du client LXD
  • exec — MĂ©thode du client LXD qui exĂ©cute la commande dans le conteneur
  • jupyterlab — Identifiant du conteneur
  • -- — ClĂ© spĂ©ciale qui indique de ne pas interprĂ©ter les clĂ©s suivantes comme des clĂ©s de lxc et de transmettre la chaĂźne restante telle quelle dans le conteneur
  • apk — Gestionnaire de paquets de la distribution Alpine Linux
  • add — MĂ©thode du gestionnaire de paquets qui installe les paquets mentionnĂ©s aprĂšs la commande

Ensuite, installons le fuseau horaire dans le systĂšme Europe/Moscow:

lxc exec jupyterlab -- cp /usr/share/zoneinfo/Europe/Moscow /etc/localtime

AprÚs l'installation du fuseau horaire, le paquet tzdata n'est plus nécessaire dans le systÚme, il prendra de la place, donc, supprimons-le :

lxc exec jupyterlab -- apk del tzdata

VĂ©rifions le fuseau horaire :

lxc exec jupyterlab -- date

Mer Apr 15 10:49:56 MSK 2020

Pour ne pas perdre beaucoup de temps Ă  configurer Bash pour les nouveaux utilisateurs dans le conteneur, nous allons copier les fichiers skel prĂȘts de la systĂšme hĂŽte. Cela permettra d'embellir Bash dans le conteneur en mode interactif. Mon systĂšme hĂŽte est Manjaro Linux et les fichiers copiĂ©s /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors conviennent en principe Ă  Alpine Linux et ne posent pas de problĂšmes critiques, mais chez vous cela peut ĂȘtre une autre distribution et vous devez gĂ©rer cela par vous-mĂȘme en cas d'erreur lors du dĂ©marrage de Bash dans le conteneur.

Copions les fichiers skel dans le conteneur. Clé --create-dirs créera les répertoires nécessaires s'ils n'existent pas :

lxc file push /etc/skel/.bash_profile jupyterlab/etc/skel/.bash_profile --create-dirs
lxc file push /etc/skel/.bashrc jupyterlab/etc/skel/.bashrc
lxc file push /etc/skel/.dir_colors jupyterlab/etc/skel/.dir_colors

Pour l'utilisateur root déjà existant, nous copierons dans le répertoire personnel les fichiers skel copiés dans le conteneur :

lxc exec jupyterlab -- cp /etc/skel/.bash_profile /root/.bash_profile
lxc exec jupyterlab -- cp /etc/skel/.bashrc /root/.bashrc
lxc exec jupyterlab -- cp /etc/skel/.dir_colors /root/.dir_colors

Dans Alpine Linux, une interface shell systÚme est installée pour les utilisateurs /bin/sh, nous allons la remplacer chez root l'utilisateur par Bash :

lxc exec jupyterlab -- usermod --shell=/bin/bash root

Pour que root l'utilisateur n'était pas sans mot de passe, il doit définir un mot de passe. La commande suivante générera et installera un nouveau mot de passe aléatoire que vous verrez sur l'écran de la console aprÚs son exécution :

lxc exec jupyterlab -- /bin/bash -c "PASSWD=$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 12); echo "root:$PASSWD" | chpasswd && echo "Nouveau mot de passe : $PASSWD""

Nouveau mot de passe : sFiXEvBswuWA

De plus, crĂ©ons un nouvel utilisateur systĂšme — jupyter pour lequel nous configurerons plus tard JupyterLab:

lxc exec jupyterlab -- useradd --create-home --shell=/bin/bash jupyter

Générons et installons un mot de passe :

lxc exec jupyterlab -- /bin/bash -c "PASSWD=$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 12); echo "jupyter:$PASSWD" | chpasswd && echo "Nouveau mot de passe : $PASSWD""

Nouveau mot de passe : ZIcbzWrF8tki

Ensuite, exécutons deux commandes, la premiÚre créera un groupe systÚme sudo, et la deuxiÚme ajoutera l'utilisateur à celui-ci jupyter:

lxc exec jupyterlab -- groupadd --system sudo
lxc exec jupyterlab -- groupmems --group sudo --add jupyter

VĂ©rifions dans quels groupes appartient l'utilisateur jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Tout est bon, continuons.

Permettons à tous les utilisateurs faisant partie du groupe sudo d'utiliser la commande sudo. Pour cela, exécutez le script suivant, qui sed décommentera la ligne de paramÚtre dans le fichier de configuration /etc/sudoers:

lxc exec jupyterlab -- /bin/bash -c "sed --in-place -e '/^#[ t]*%sudo[ t]*ALL=(ALL)[ t]*ALL$/ s/^[# ]*// ' /etc/sudoers"

Installation et configuration de JupyterLab ^

JupyterLab — c'est une application Python, donc nous devons d'abord installer cet interprĂ©teur. De plus, JupyterLab nous allons installer en utilisant le gestionnaire de paquets Python pip, et non le systĂšme, car dans le dĂ©pĂŽt systĂšme il peut ĂȘtre obsolĂšte, et donc, nous devons rĂ©soudre manuellement les dĂ©pendances en installant les paquets suivants — python3 python3-dev gcc libc-dev zeromq-dev:

lxc exec jupyterlab -- apk add python3 python3-dev gcc libc-dev zeromq-dev

Mettons Ă  jour les modules Python et le gestionnaire de paquets pip Ă  la version actuelle :

lxc exec jupyterlab -- python3 -m pip install --upgrade pip setuptools wheel

Nous installons JupyterLab via le gestionnaire de paquets pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Puisque les extensions dans JupyterLab sont expérimentales et ne sont pas officiellement livrées avec le paquet jupyterlab, donc nous devons les installer et les configurer manuellement.

Installons NodeJS et son gestionnaire de paquets — NPM, car JupyterLab ils sont utilisĂ©s pour ses extensions :

lxc exec jupyterlab -- apk add nodejs npm

Pour que les extensions de JupyterLab que nous allons installer fonctionnent, elles doivent ĂȘtre installĂ©es dans le rĂ©pertoire utilisateur car l'application sera lancĂ©e par l'utilisateur jupyter. Le problĂšme est qu'il n'y a pas de paramĂštre dans la commande de lancement qui permet de passer un rĂ©pertoire, l'application ne reconnaĂźt que la variable d'environnement et nous devons donc la dĂ©finir. Pour cela, nous allons Ă©crire la commande d'exportation de la variable JUPYTERLAB_DIR dans l'environnement utilisateur jupyter, dans le fichier .bashrc, qui s'exĂ©cute Ă  chaque fois que l'utilisateur se connecte :

lxc exec jupyterlab -- su -l jupyter -c "echo -e "nexport JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab" >> .bashrc"

Avec la commande suivante, nous allons installer une extension spĂ©ciale — le gestionnaire d'extensions dans JupyterLab:

lxc exec jupyterlab -- su -l jupyter -c "export JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab; jupyter labextension install --no-build @jupyter-widgets/jupyterlab-manager"

Tout est maintenant prĂȘt pour le premier lancement JupyterLab, mais nous pouvons encore installer quelques extensions utiles :

  • toc — Table des matiĂšres, gĂ©nĂšre une liste des titres dans l'article / le carnet
  • jupyterlab-horizon-theme — ThĂšme d'interface utilisateur
  • jupyterlab_neon_theme — ThĂšme d'interface utilisateur
  • jupyterlab-ubu-theme — Un autre thĂšme du crĂ©ateur de cet article 🙂 Mais dans ce cas, l'installation se fera Ă  partir du dĂ©pĂŽt GitHub

Alors, exécutez les commandes suivantes successivement pour installer ces extensions :

lxc exec jupyterlab -- su -l jupyter -c "export JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab; jupyter labextension install --no-build @jupyterlab/toc @mohirio/jupyterlab-horizon-theme @yeebc/jupyterlab_neon_theme"
lxc exec jupyterlab -- su -l jupyter -c "wget -c https://github.com/microcoder/jupyterlab-ubu-theme/archive/master.zip"
lxc exec jupyterlab -- su -l jupyter -c "unzip -q master.zip && rm master.zip"
lxc exec jupyterlab -- su -l jupyter -c "export JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab; jupyter labextension install --no-build jupyterlab-ubu-theme-master"
lxc exec jupyterlab -- su -l jupyter -c "rm -r jupyterlab-ubu-theme-master"

AprÚs l'installation des extensions, nous devons les compiler, car précédemment, lors de l'installation nous avions spécifié la clé --no-build pour gagner du temps. Maintenant, nous allons accélérer considérablement en les compilant ensemble en une seule fois :

lxc exec jupyterlab -- su -l jupyter -c "export JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab; jupyter lab build"

Maintenant, exĂ©cutez les deux commandes suivantes pour le premier lancement JupyterLabOn pourrait le lancer d'une seule commande, mais dans ce cas, la commande de dĂ©marrage, que l'on doit garder en tĂȘte, sera mĂ©morisĂ©e par bash dans le conteneur, et non sur l'hĂŽte, oĂč il y a dĂ©jĂ  suffisamment de commandes enregistrĂ©es dans l'historique 🙂

Connectez-vous au conteneur en tant qu'utilisateur jupyter:

lxc exec jupyterlab -- su -l jupyter

Ensuite, lancez JupyterLab avec les clés et les paramÚtres comme indiqué :

[jupyter@jupyterlab ~]$ jupyter lab --ip=0.0.0.0 --no-browser

AccĂ©dez dans votre navigateur web Ă  l'adresse http://10.0.5.5:8888 et sur la page qui s'ouvre, entrez token l'accĂšs que vous verrez dans la console. Copiez-le et collez-le sur la page, puis cliquez Connexion. AprĂšs vous ĂȘtre connectĂ©, allez Ă  gauche dans le menu des extensions, comme indiquĂ© ci-dessous, oĂč on vous demandera, lors de l'activation du gestionnaire d'extensions, d'accepter les risques de sĂ©curitĂ© liĂ©s Ă  l'installation d'extensions de tiers pour lesquelles l'Ă©quipe JupyterLab development n'est pas responsable :

Lancement de Jupyter sur l'orbite LXD

Cependant, c'est justement pour cela que nous isolons complĂštement JupyterLab et le plaçons dans un conteneur, afin que les extensions tierces nĂ©cessitant et utilisant NodeJS ne puissent pas, au minimum, voler des donnĂ©es sur le disque, Ă  l'exception de celles que nous ouvrirons Ă  l'intĂ©rieur du conteneur. AccĂ©der Ă  vos documents privĂ©s sur l'hĂŽte /home depuis les processus dans le conteneur sera difficile, et mĂȘme si c'est possible, cela nĂ©cessiterait des privilĂšges de fichiers dans le systĂšme hĂŽte, puisque nous exĂ©cutons le conteneur en mode non privilĂ©giĂ©. En tenant compte de ces informations, vous pouvez Ă©valuer le risque d'activation des extensions dans JupyterLab.

Les notebooks IPython crĂ©Ă©s (pages dans JupyterLab) seront maintenant crĂ©Ă©s dans le rĂ©pertoire personnel de l'utilisateur — /home/jupyter, mais nous prĂ©voyons de sĂ©parer (partager) les donnĂ©es entre l'hĂŽte et le conteneur, donc, retournez Ă  la console et arrĂȘtez JupyterLab en rĂ©alisant le raccourci — CTRL+C et en rĂ©pondant y Ă  la requĂȘte. Ensuite, terminez la session interactive de l'utilisateur jupyter en utilisant le raccourci CTRL+D.

Partageons des données avec l'hÎte ^

Pour partager des donnĂ©es avec l'hĂŽte, il est nĂ©cessaire de crĂ©er dans le conteneur un tel dispositif qui le permet, et pour cela, exĂ©cutez la commande suivante oĂč nous prĂ©cisons les clĂ©s suivantes :

  • lxc config device add — La commande ajoute la configuration du dispositif
  • jupyter — L'identifiant du conteneur dans lequel la configuration est ajoutĂ©e
  • hostfs — L'identifiant du dispositif. Vous pouvez donner n'importe quel nom.
  • disk — Le type de dispositif est spĂ©cifiĂ©
  • chemin — Chemin dans le conteneur oĂč LXD montera ce dispositif
  • source — Indiquez la source, le chemin du rĂ©pertoire sur l'hĂŽte que vous souhaitez partager avec le conteneur. SpĂ©cifiez le chemin selon vos prĂ©fĂ©rences.
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Pour le rĂ©pertoire /home/dv/projects/ipython-notebooks le conteneur doit avoir des autorisations dĂ©finies pour l'utilisateur qui a actuellement l'UID Ă©gal Ă  SubUID + UID, consultez le chapitre SĂ©curitĂ©. PrivilĂšges des conteneurs dans l'article FonctionnalitĂ©s de base de LXD — systĂšmes de conteneurs sous Linux.

DĂ©finissez les autorisations sur l'hĂŽte, oĂč le propriĂ©taire sera l'utilisateur du conteneur jupyter, et la variable $USER indiquera votre utilisateur hĂŽte en tant que groupe :

sudo chown 1001000:$USER /home/dv/projects/ipython-notebooks

Hello, World! ^

Si vous avez encore une session de console ouverte dans le conteneur avec JupyterLab, redémarrez-la avec la nouvelle option --notebook-dir en définissant la valeur /mnt/hostfs comme le chemin vers la racine des notebooks dans le conteneur pour le dispositif que nous avons créé à l'étape précédente :

jupyter lab --ip=0.0.0.0 --no-browser --notebook-dir=/mnt/hostfs

Ensuite, accédez à la page http://10.0.5.5:8888 et créez votre premier notebook en cliquant sur le bouton de la page comme indiqué sur l'image ci-dessous :

Lancement de Jupyter sur l'orbite LXD

Ensuite, dans le champ de la page, entrez le code en Python qui affichera le classique Hello World!. Une fois que vous avez terminé d'entrer, appuyez sur CTRL+ENTER ou le bouton « play » sur la barre d'outils en haut pour que JupyterLab exécute cela :

Lancement de Jupyter sur l'orbite LXD

Tout est presque prĂȘt Ă  ĂȘtre utilisĂ©, mais il ne sera pas intĂ©ressant si nous n'installons pas des modules Python supplĂ©mentaires (des applications complĂštes) qui permettent d'Ă©tendre considĂ©rablement les capacitĂ©s standard de Python dans JupyterLab, donc, continuons 🙂

P.S. Il est intéressant de noter que l'ancienne implémentation Jupyter sous le nom de code Jupyter Notebook n'a pas disparu et existe parallÚlement à JupyterLab. Pour accéder à l'ancienne version, rendez-vous sur le lien en ajoutant le suffixe/tree, et l'accÚs à la nouvelle version se fait avec le suffixe /lab, mais il n'est pas nécessaire de le spécifier :

Élargissons les possibilitĂ©s de Python ^

Dans cette section, nous installerons de puissants modules du langage Python tels que NumPy, Pandas, Matplotlib, IPyWidgets dont les résultats s'intÚgrent dans les notebooks. JupyterLab.

Avant d'installer les modules Python énumérés via le gestionnaire de paquets, pip nous devons d'abord autoriser les dépendances systÚme dans Alpine Linux :

  • g++ — NĂ©cessaire pour la compilation des modules, car certains d'entre eux sont implĂ©mentĂ©s en C++ et sont liĂ©s Ă  Python au moment de l'exĂ©cution en tant que modules binaires.
  • freetype-dev — dĂ©pendance pour le module Python Matplotlib

Installons les dépendances :

lxc exec jupyterlab -- apk add g++ freetype-dev

Il y a un problÚme : dans l'état actuel de la distribution Alpine Linux, il est impossible de compiler la nouvelle version de NumPy, une erreur de compilation se produira que je n'ai pas réussi à résoudre.

ERREUR: Impossible de construire des roues pour numpy qui utilisent PEP 517 et ne peuvent pas ĂȘtre installĂ©es directement

C'est pourquoi nous allons installer ce module en tant que paquet systÚme qui distribue déjà une version précompilée, mais un peu plus ancienne que celle actuellement disponible sur le site :

lxc exec jupyterlab -- apk add py3-numpy py3-numpy-dev

Ensuite, installons les modules Python via le gestionnaire de paquets. pipPatientez un peu, car certains modules vont ĂȘtre compilĂ©s et cela prendra quelques minutes. Sur ma machine, la compilation a pris environ 15 minutes :

lxc exec jupyterlab -- python3 -m pip install pandas ipywidgets matplotlib

Vidons les caches d'installation :

lxc exec jupyterlab -- rm -rf /home/*/.cache/pip/*
lxc exec jupyterlab -- rm -rf /root/.cache/pip/*

Testons les modules dans JupyterLab ^

Si vous avez une instance en cours d'exĂ©cution JupyterLab, redĂ©marrez-la pour que les nouveaux modules installĂ©s soient activĂ©s. Pour ce faire, dans la session de console, appuyez sur CTRL+C lĂ  oĂč elle est en cours d'exĂ©cution et entrez y en rĂ©ponse Ă  la demande d'arrĂȘt, puis redĂ©marrez-la JupyterLab en appuyant sur la flĂšche « vers le haut » sur le clavier pour ne pas avoir Ă  saisir la commande Ă  nouveau, puis EntrĂ©e pour dĂ©marrer :

jupyter lab --ip=0.0.0.0 --no-browser --notebook-dir=/mnt/hostfs

Allez sur la page http://10.0.5.5:8888/lab ou actualisez la page dans le navigateur et entrez ensuite le code suivant dans une nouvelle cellule du notebook :

%matplotlib inline

from ipywidgets import interactive
import matplotlib.pyplot as plt
import numpy as np

def f(m, b):
    plt.figure(2)
    x = np.linspace(-10, 10, num=1000)
    plt.plot(x, m * x + b)
    plt.ylim(-5, 5)
    plt.show()

interactive_plot = interactive(f, m=(-2.0, 2.0), b=(-3, 3, 0.5))
output = interactive_plot.children[-1]
output.layout.height = '350px'
interactive_plot

Vous devriez obtenir un rĂ©sultat comme sur l'image ci-dessous, oĂč IPyWidgets gĂ©nĂšre un Ă©lĂ©ment UI sur la page qui interagit de maniĂšre interactive avec le code source, et aussi Matplotlib affiche le rĂ©sultat du code sous forme d'image comme un graphique de fonction :

Lancement de Jupyter sur l'orbite LXD

De nombreux exemples IPyWidgets vous pouvez les trouver dans des tutoriels ici

Quoi d'autre ? ^

Bravo Ă  vous d'ĂȘtre restĂ©s et d'avoir atteint la fin de l'article. J'ai volontairement Ă©vitĂ© de publier un script prĂȘt Ă  l'emploi Ă  la fin de l'article qui installerait JupyterLab en « un clic », pour encourager les travailleurs 🙂 Mais vous pouvez le faire vous-mĂȘme, car vous savez maintenant comment, en regroupant les commandes dans un seul script Bash 🙂

Vous pouvez aussi :

  • Attribuer un nom rĂ©seau au conteneur au lieu de l'adresse IP en le spĂ©cifiant dans une simple /etc/hosts et dans le navigateur, taper l'adresse http://jupyter.local:8888
  • Jouer avec les limites de ressources du conteneur, pour cela, lisez le chapitre dans les capacitĂ©s de base de LXD ou obtenez plus d'informations sur le site du dĂ©veloppeur de LXD.
  • Changer le thĂšme :

Lancement de Jupyter sur l'orbite LXD

Et beaucoup d'autres choses que vous pouvez faire ! C'est tout. Je vous souhaite bonne chance !

MISE À JOUR : 15.04.2020 18:30 — J'ai corrigĂ© des erreurs dans le chapitre « Bonjour, le monde ! »
MISE À JOUR : 16.04.2020 10:00 — J'ai ajustĂ© et ajoutĂ© du texte dans la description de l'activation du gestionnaire d'extensions JupyterLab
MISE À JOUR : 16.04.2020 10:40 — J'ai corrigĂ© les erreurs trouvĂ©es dans le texte et lĂ©gĂšrement amĂ©liorĂ© le chapitre « Installation des logiciels de base et configuration du systĂšme »

Source : habr.com

Acheter un hĂ©bergement fiable pour les sites avec protection DDoS, serveurs VPS VDS đŸ”„ Acheter un hĂ©bergement fiable pour les sites avec protection DDoS, serveurs VPS VDS | ProHoster