ProHoster > Blog > administration > Lancer Jupyter sur l'orbite LXD

Lancer Jupyter sur l'orbite LXD

Avez-vous déjà dû expérimenter du code ou des utilitaires système sous Linux pour ne pas vous soucier du système de base et ne pas tout détruire en cas d'erreur dans le code qui doit s'exécuter avec les privilèges root ?

Mais qu’en est-il du fait que disons que vous ayez besoin de tester ou d’exécuter tout un cluster de divers microservices sur une seule machine ? Une centaine, voire un millier ?

Avec des machines virtuelles gérées par un hyperviseur, de tels problèmes peuvent et seront résolus, mais à quel prix ? Par exemple, un conteneur dans LXD basé sur la distribution Alpine Linux ne consomme que 7.60MB RAM et où occupe la partition racine après le démarrage 9.5MB! Comment trouves-tu ça, Elon Musk ? Je recommande de vérifier capacités de base de LXD - un système de conteneurs sous Linux

Une fois qu'il est devenu clair en général ce que sont les conteneurs LXD, allons plus loin et réfléchissons, et s'il existait une telle plate-forme de récolte où vous pourriez exécuter du code pour l'hôte en toute sécurité, générer des graphiques, lier dynamiquement (interactivement) des widgets d'interface utilisateur à votre code, compléter le code avec du texte avec du blackjack... formatage ? Une sorte de blog interactif ? Wow... je le veux ! Vouloir! 🙂

Regardez sous le chat où nous allons lancer dans un conteneur laboratoire jupyter - la prochaine génération d'interface utilisateur au lieu du Jupyter Notebook obsolète, et nous installerons également des modules Python tels que NumPy, Pandas, matplotlib, IPyWidgets ce qui vous permettra de faire tout ce qui est indiqué ci-dessus et de tout enregistrer dans un fichier spécial - un ordinateur portable IPython.

Lancer Jupyter sur l'orbite LXD

Plan de décollage orbital ^

Lancer Jupyter sur l'orbite LXD

Décrivons un bref plan d'action pour nous permettre de mettre plus facilement en œuvre le programme ci-dessus :

  • Installons et lançons un conteneur basé sur le kit de distribution Alpine Linux. Nous utiliserons cette distribution car elle vise le minimalisme et n'y installerons que les logiciels les plus nécessaires, rien de superflu.
  • Ajoutons un disque virtuel supplémentaire dans le conteneur et donnons-lui un nom - hostfs et montez-le sur le système de fichiers racine. Ce disque permettra d'utiliser des fichiers sur l'hôte à partir d'un répertoire donné à l'intérieur du conteneur. Ainsi, nos données seront indépendantes du conteneur. Si le conteneur est supprimé, les données resteront sur l'hôte. En outre, ce schéma est utile pour partager les mêmes données entre plusieurs conteneurs sans utiliser les mécanismes réseau standard de la distribution 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 eux
  • Installons et lançons laboratoire jupyter, personnalisez l'apparence, installez des extensions pour celui-ci.

Dans cet article nous commencerons par lancer le conteneur, nous n'envisagerons pas d'installer et de configurer LXD, vous pourrez retrouver tout cela dans un autre article - Fonctionnalités de base de LXD - Systèmes de conteneurs Linux.

Installation et configuration du système de base ^

Nous créons un conteneur avec la commande dans laquelle nous spécifions l'image - alpine3, identifiant du conteneur - jupyterlab et, si nécessaire, des profils de configuration :

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

Ici, j'utilise un profil de configuration hddroot qui spécifie de créer un conteneur avec une partition racine dans Pool de stockage 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 donne l'opportunité d'expérimenter des conteneurs sur le disque HDD, économisant ainsi les ressources du disque SSD, qui est également disponible dans mon système 🙂 pour lequel j'ai créé un profil de configuration distinct ssdroot.

Une fois le conteneur créé, il se trouve dans l'état STOPPED, nous devons donc le démarrer en y exécutant le système init :

lxc start jupyterlab

Affichons une liste de conteneurs dans LXD à l'aide de la clé -c qui indique quel caffichage des colonnes :

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 aléatoirement, puisque 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 Linux.

Nous allons changer cette adresse IP en une adresse plus mémorisable en créant une interface réseau au niveau du conteneur, et non au niveau du profil de configuration comme c'est le cas maintenant dans la configuration actuelle. Vous n’êtes pas obligé de le faire, vous pouvez l’ignorer.

Création d'une interface réseau eth0 que nous lions au switch (pont réseau) lxdbr0 dans lequel nous avons activé NAT selon l'article précédent et le conteneur aura désormais accès à Internet, et nous attribuons également 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 avoir ajouté un périphérique, le conteneur doit être redémarré :

lxc restart jupyterlab

Vérification de l'état du conteneur :

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

Installation du logiciel de base et configuration du système ^

Pour administrer notre conteneur, vous devez installer les logiciels suivants :

Emballage Papier
Description

bash
Le shell GNU Bourne Again

bash-achèvement
Achèvement programmable pour le shell bash

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

ombre
Suite d'outils de gestion de mots de passe et de comptes avec prise en charge des fichiers fantômes et PAM

tzdata
Sources pour les données de fuseau horaire et d'heure d'été

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

De plus, vous pouvez installer la prise en charge dans les pages de manuel du système en installant les packages suivants - man man-pages mdocml-apropos less

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

Regardons les commandes et les touches que nous avons utilisées :

  • lxc — Appeler le client LXD
  • exec - Méthode client LXD qui exécute une commande dans le conteneur
  • jupyterlab — ID du conteneur
  • -- - Une clé spéciale qui précise de ne pas interpréter d'autres clés comme des clés pour lxc et transmettez le reste de la chaîne tel quel au conteneur
  • apk — Gestionnaire de packages de distribution Alpine Linux
  • add — Une méthode de gestionnaire de packages qui installe les packages spécifiés après la commande

Ensuite, nous définirons un fuseau horaire dans le système Europe/Moscow:

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

Après avoir installé le fuseau horaire, le package tzdata n'est plus nécessaire dans le système, il prendra de la place, alors supprimons-le :

lxc exec jupyterlab -- apk del tzdata

Vérification du fuseau horaire :

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Afin de ne pas passer beaucoup de temps à configurer Bash pour les nouveaux utilisateurs dans le conteneur, dans les étapes suivantes, nous copierons les fichiers skel prêts à l'emploi du système hôte vers celui-ci. Cela vous permettra d'embellir Bash dans un conteneur de manière interactive. Mon système hôte est Manjaro Linux et les fichiers en cours de copie /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors en principe, ils conviennent à Alpine Linux et ne posent pas de problèmes critiques, mais vous pouvez avoir une distribution différente et vous devez déterminer indépendamment s'il y a une erreur lors de l'exécution de Bash dans le conteneur.

Copiez 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 un utilisateur root déjà existant, copiez les fichiers skel que vous venez de copier dans le conteneur vers le répertoire personnel :

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

Alpine Linux installe un shell système pour les utilisateurs /bin/sh, nous le remplacerons par root utilisateur dans Bash :

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

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 définira un nouveau mot de passe aléatoire pour lui, 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 "New Password: $PASSWD""

New Password: sFiXEvBswuWA

Créons également un nouvel utilisateur système - jupyter pour lequel nous configurerons plus tard laboratoire jupyter:

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

Générons et définissons un mot de passe pour cela :

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

New Password: ZIcbzWrF8tki

Ensuite, nous exécuterons deux commandes, la première créera un groupe système sudo, et le second y ajoutera un utilisateur jupyter:

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

Voyons à quels groupes appartient l'utilisateur jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Tout va bien, passons à autre chose.

Autoriser tous les utilisateurs membres du groupe sudo utiliser la commande sudo. Pour ce faire, exécutez le script suivant, où sed décommente 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"

Installer et configurer JupyterLab ^

laboratoire jupyter est une application Python, il faut donc d'abord installer cet interpréteur. Aussi, laboratoire jupyter nous allons installer en utilisant le gestionnaire de packages Python pip, et non celui du système, car il peut être obsolète dans le référentiel système et par conséquent, nous devons résoudre manuellement ses dépendances en installant les packages 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 packages pip à la version actuelle :

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

Fixer laboratoire jupyter via le gestionnaire de paquets pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Depuis les extensions en laboratoire jupyter sont expérimentaux et ne sont pas officiellement livrés avec le package jupyterlab, nous devons donc l'installer et le configurer manuellement.

Installons NodeJS et le gestionnaire de packages correspondant - NPM, puisque laboratoire jupyter les utilise pour ses extensions :

lxc exec jupyterlab -- apk add nodejs npm

Aux extensions pour laboratoire jupyter que nous allons installer ont fonctionné, ils doivent être installés dans le répertoire utilisateur puisque l'application sera lancée depuis l'utilisateur jupyter. Le problème est qu'il n'y a aucun paramètre dans la commande de lancement qui peut être passé à un répertoire ; l'application n'accepte qu'une variable d'environnement et il faut donc la définir. Pour ce faire, nous écrirons la commande d'exportation de variables JUPYTERLAB_DIR dans l'environnement de l'utilisateur jupyter, pour déposer .bashrcqui est exécuté à 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"

La commande suivante installera une extension spéciale - gestionnaire d'extensions dans laboratoire jupyter:

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

Maintenant tout est prêt pour le premier lancement laboratoire jupyter, mais nous pouvons quand même installer quelques extensions utiles :

  • toc — Table des matières, génère une liste de titres dans un article/un cahier
  • jupyterlab-horizon-theme — Thème de l'interface utilisateur
  • jupyterlab_neon_theme — Thème de l'interface utilisateur
  • jupyterlab-ubu-theme - Un autre thème de l'auteur cet article :) Mais dans ce cas, l'installation à partir du référentiel GitHub sera affichée

Alors, exécutez les commandes suivantes séquentiellement 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 avoir installé les extensions, il faut les compiler, puisque précédemment, lors de l'installation, nous avons précisé la clé --no-build gagner du temps. Nous allons maintenant accélérer considérablement en les compilant en une seule fois :

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

Exécutez maintenant les deux commandes suivantes pour l'exécuter pour la première fois laboratoire jupyter. Il serait possible de le lancer avec une seule commande, mais dans ce cas, la commande de lancement, difficile à retenir dans votre esprit, sera mémorisée par bash dans le conteneur, et non sur l'hôte, où il y a déjà suffisamment de commandes pour les enregistrer dans l'historique :)

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

lxc exec jupyterlab -- su -l jupyter

Ensuite, exécutez laboratoire jupyter avec les clés et les paramètres comme indiqué :

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

Accédez à l'adresse dans votre navigateur Web http://10.0.5.5:8888 et sur la page qui s'ouvre, entrez jeton accès que vous verrez dans la console. Copiez-le et collez-le sur la page, puis cliquez sur Connexion. Après vous être connecté, rendez-vous dans le menu des extensions à gauche, comme le montre la figure ci-dessous, où il vous sera demandé, lors de l'activation du gestionnaire d'extensions, de prendre des risques de sécurité en installant des extensions de tiers pour lesquelles la commande Développement JupyterLab n'est pas responsable :

Lancer Jupyter sur l'orbite LXD

Cependant, nous isolons l'ensemble laboratoire jupyter et placez-le dans un conteneur afin que les extensions tierces qui nécessitent et utilisent NodeJS ne puissent au moins voler des données sur le disque autres que celles que nous ouvrons à l'intérieur du conteneur. Accédez à vos documents privés sur l'hôte dans /home Il est peu probable que les processus du conteneur réussissent, et s'ils réussissent, vous devez alors disposer de privilèges sur les fichiers du système hôte, car nous exécutons le conteneur dans mode non privilégié. Sur la base de ces informations, vous pouvez évaluer le risque d'inclure des extensions dans laboratoire jupyter.

Création de notebooks IPython (pages dans laboratoire jupyter) sera maintenant créé dans le répertoire personnel de l'utilisateur - /home/jupyter, mais nos plans sont de diviser les données (partage) entre l'hôte et le conteneur, alors revenez à la console et arrêtez laboratoire jupyter en exécutant le raccourci clavier - CTRL+C et répondre y à la demande. Terminez ensuite la session interactive de l'utilisateur jupyter compléter un raccourci clavier CTRL+D.

Partager des données avec l'hébergeur ^

Pour partager des données avec l'hôte, vous devez créer un périphérique dans le conteneur qui vous permet de le faire et pour ce faire, exécutez la commande suivante où nous spécifions les clés suivantes :

  • lxc config device add — La commande ajoute la configuration de l'appareil
  • jupyter — ID du conteneur auquel la configuration est ajoutée
  • hostfs - Reference de l'appareil. Vous pouvez définir n’importe quel nom.
  • disk — Le type d'appareil est indiqué
  • path — Spécifie le chemin dans le conteneur sur lequel LXD montera ce périphérique
  • source — Spécifiez la source, le chemin d'accès au répertoire sur l'hôte que vous souhaitez partager avec le conteneur. Précisez 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 catalogue /home/dv/projects/ipython-notebooks l'autorisation doit être définie sur l'utilisateur du conteneur qui possède actuellement un UID égal à SubUID + UID, voir chapitre Sécurité. Privilèges de conteneur Article Fonctionnalités de base de LXD - Systèmes de conteneurs Linux.

Définir l'autorisation sur l'hôte, où le propriétaire sera l'utilisateur du conteneur jupyter, et la variable $USER spécifiera votre utilisateur hôte en tant que groupe :

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

Bonjour le monde! ^

Si vous avez encore une session console ouverte dans le conteneur avec laboratoire jupyter, puis redémarrez-le avec une nouvelle clé --notebook-dir en définissant la valeur /mnt/hostfs comme chemin d'accès à la racine des ordinateurs portables dans le conteneur du périphérique que nous avons créé à l'étape précédente :

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

Rendez-vous ensuite sur la page http://10.0.5.5:8888 et créez votre premier ordinateur portable en cliquant sur le bouton de la page comme indiqué dans l'image ci-dessous :

Lancer Jupyter sur l'orbite LXD

Ensuite, dans le champ de la page, saisissez le code Python qui affichera le classique Hello World!. Lorsque vous avez fini de saisir, appuyez sur CTRL+ENTER ou le bouton « play » dans la barre d'outils en haut pour que JupyterLab fasse ceci :

Lancer Jupyter sur l'orbite LXD

À ce stade, presque tout est prêt à être utilisé, mais cela ne sera pas intéressant si nous n'installons pas de modules Python supplémentaires (applications à part entière) qui peuvent étendre considérablement les capacités standard de Python dans laboratoire jupyter, donc passons à autre chose :)

PS Ce qui est intéressant c'est que l'ancienne implémentation Jupiter sous le nom de code Jupyter Notebook n'a pas disparu et il existe en parallèle avec laboratoire jupyter. Pour passer à l'ancienne version, suivez le lien en ajoutant le suffixe dans l'adresse/tree, et le passage à la nouvelle version s'effectue avec le suffixe /lab, mais il n'est pas nécessaire de le préciser :

Extension des capacités de Python ^

Dans cette section, nous installerons des modules de langage Python aussi puissants que NumPy, Pandas, matplotlib, IPyWidgets dont les résultats sont intégrés dans les ordinateurs portables laboratoire jupyter.

Avant d'installer les modules Python répertoriés via le gestionnaire de packages pip il faut d'abord résoudre les dépendances système dans Alpine Linux :

  • g++ — Nécessaire à la compilation des modules, puisque certains d'entre eux sont implémentés dans le langage C + + et connectez-vous à Python au moment de l'exécution en tant que modules binaires
  • freetype-dev - dépendance pour le module Python matplotlib

Installation des 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 ne sera pas possible de compiler la nouvelle version de NumPy ; une erreur de compilation apparaîtra que je n'ai pas pu résoudre :

ERREUR: Impossible de créer des roues pour numpy qui utilisent PEP 517 et ne peuvent pas être installées directement

Nous allons donc installer ce module comme un package système distribuant une version déjà 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, installez les modules Python via le gestionnaire de packages pip. Soyez patient car certains modules seront compilés et peuvent prendre quelques minutes. Sur ma machine, la compilation a pris environ 15 minutes :

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

Vider les caches d'installation :

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

Modules de test dans JupyterLab ^

Si vous courez laboratoire jupyter, redémarrez-le pour que les modules nouvellement installés soient activés. Pour ce faire, dans une session de console, cliquez sur CTRL+C où vous le faites fonctionner et entrez y pour arrêter la demande puis recommencer laboratoire jupyter en appuyant sur la flèche haut du clavier pour ne plus saisir la commande puis Enter pour le démarrer :

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

ерейдите на страницу http://10.0.5.5:8888/lab ou actualisez la page dans votre navigateur, puis saisissez le code suivant dans une nouvelle cellule du bloc-notes :

%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 dans l'image ci-dessous, où IPyWidgets génère un élément d'interface utilisateur sur la page qui interagit de manière interactive avec le code source, et également matplotlib affiche le résultat du code sous forme d'image sous forme de graphique de fonction :

Lancer Jupyter sur l'orbite LXD

De nombreux exemples IPyWidgets tu peux le trouver dans les tutoriels ici

Quoi d'autre? ^

Bravo si vous êtes resté et avez atteint la toute fin de l'article. Je n'ai délibérément pas posté à la fin de l'article un script prêt à l'emploi qui installerait laboratoire jupyter en "un clic" pour encourager les travailleurs :) Mais vous pouvez le faire vous-même, puisque vous savez déjà comment faire, après avoir rassemblé les commandes dans un seul script Bash :)

Vous pouvez aussi:

  • Définissez un nom de réseau pour le conteneur au lieu d'une adresse IP en l'écrivant de manière simple. /etc/hosts et tapez l'adresse dans le navigateur http://jupyter.local:8888
  • Jouez avec la limite de ressources du conteneur, pour cela lisez le chapitre dans capacités de base de LXD ou obtenez plus d'informations sur le site des développeurs LXD.
  • Changer le thème :

Lancer Jupyter sur l'orbite LXD

Et bien plus encore, vous pouvez faire ! C'est tout. Je te souhaite du succès!

MISE À JOUR : 15.04.2020/18/30 XNUMXhXNUMX - Erreurs corrigées dans le chapitre « Hello, World ! »
MISE À JOUR : 16.04.2020/10/00 XNUMXhXNUMX — Texte corrigé et ajouté dans la description de l'activation du gestionnaire d'extensions laboratoire jupyter
MISE À JOUR : 16.04.2020/10/40 XNUMXhXNUMX — Erreurs corrigées trouvées dans le texte et légèrement modifiées pour le mieux le chapitre « Installation du logiciel de base et configuration du système »

Source: habr.com

Ajouter un commentaire