ProHoster > Blog > Administración > Lanzamento de Jupyter na órbita LXD

Lanzamento de Jupyter na órbita LXD

Algunha vez tivo que experimentar con código ou utilidades do sistema en Linux para non preocuparse polo sistema base e non derrubar todo en caso de producirse un erro no código que debería executarse con privilexios de root?

Pero que pasa co feito de que digamos que necesitas probar ou executar todo un clúster de varios microservizos nunha máquina? Cen ou mesmo mil?

Con máquinas virtuais xestionadas por un hipervisor, este tipo de problemas pódense resolver e resolveranse, pero a que custo? Por exemplo, un contedor en LXD baseado na distribución Alpine Linux só consume 7.60MB RAM e onde ocupa a partición raíz despois do inicio 9.5MB! Como che parece isto, Elon Musk? Recomendo facer o check-out capacidades básicas de LXD - un sistema de contedores en Linux

Despois de que quedou claro en xeral cales son os contedores LXD, imos máis aló e pensemos, que pasaría se houbese unha plataforma de recolección na que puideses executar código para o servidor de forma segura, xerar gráficos, vincular dinámicamente (interactivamente) widgets da IU co teu código? completar o código con texto con blackjack... formato? Algún tipo de blog interactivo? Vaia... quero! Quere! 🙂

Mira debaixo do gato onde lanzaremos nun recipiente laboratorio jupyter - a próxima xeración de interface de usuario en lugar do anticuado Jupyter Notebook, e tamén instalaremos módulos de Python como numpy, pandas, matplotlib, IPyWidgets o que che permitirá facer todo o que se indica anteriormente e gardalo todo nun ficheiro especial: un portátil IPython.

Lanzamento de Jupyter na órbita LXD

Plan de engalaxe orbital ^

Lanzamento de Jupyter na órbita LXD

Imos esbozar un breve plan de acción para facilitarnos a implementación do esquema anterior:

  • Imos instalar e lanzar un contedor baseado no kit de distribución Linux Alpine. Utilizaremos esta distribución porque está dirixida ao minimalismo e instalaremos nela só o software máis necesario, nada superfluo.
  • Engademos un disco virtual adicional no contedor e dámoslle un nome: hostfs e montámolo no sistema de ficheiros raíz. Este disco permitirá utilizar ficheiros no host desde un determinado directorio dentro do contedor. Así, os nosos datos serán independentes do contedor. Se se elimina o contedor, os datos permanecerán no servidor. Ademais, este esquema é útil para compartir os mesmos datos entre moitos contedores sen utilizar os mecanismos de rede estándar da distribución de contedores.
  • Imos instalar Bash, sudo, as bibliotecas necesarias, engadir e configurar un usuario do sistema
  • Instalemos Python, módulos e compilemos dependencias binarias para eles
  • Imos instalar e lanzar laboratorio jupyter, personalizar a aparencia, instalar extensións para el.

Neste artigo, comezaremos co lanzamento do contedor, non consideraremos instalar e configurar LXD, podes atopar todo isto noutro artigo: Características básicas dos sistemas de contedores LXD - Linux.

Instalación e configuración do sistema básico ^

Creamos un contedor co comando no que especificamos a imaxe - alpine3, identificador do recipiente - jupyterlab e, se é necesario, perfís de configuración:

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

Aquí estou usando un perfil de configuración hddroot que especifica crear un contedor cunha partición raíz Piscina de almacenamento situado nun disco duro físico:

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

Isto dáme a oportunidade de experimentar con contedores no disco HDD, gardando os recursos do disco SSD, que tamén está dispoñible no meu sistema 🙂 para o que creei un perfil de configuración separado ssdroot.

Despois de crear o contedor, está no estado STOPPED, polo que necesitamos inicialo executando o sistema init nel:

lxc start jupyterlab

Imos amosar unha lista de contedores en LXD usando a tecla -c que indica cal cvisualización de columnas:

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

Ao crear o contedor, o enderezo IP escolleuse ao azar, xa que utilizamos un perfil de configuración default que estaba previamente configurado no artigo Características básicas dos sistemas de contedores LXD - Linux.

Cambiaremos este enderezo IP por outro máis memorable creando unha interface de rede a nivel de contedores, e non a nivel de perfil de configuración como está agora na configuración actual. Non tes que facelo, podes omitilo.

Creación dunha interface de rede eth0 que ligamos ao switch (ponte de rede) lxdbr0 no que activamos NAT segundo o artigo anterior e agora o contedor terá acceso a Internet e tamén asignamos un enderezo IP estático á interface - 10.0.5.5:

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

Despois de engadir un dispositivo, o contedor debe reiniciarse:

lxc restart jupyterlab

Comprobación do estado do recipiente:

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

Instalación de software básico e configuración do sistema ^

Para administrar o noso contedor, cómpre instalar o seguinte software:

Paquete
descrición

bater
O shell de GNU Bourne Again

bash-completación
Finalización programable para o shell bash

sudo
Dálle a certos usuarios a posibilidade de executar algúns comandos como root

sombra
Paquete de ferramentas de xestión de contrasinais e contas con soporte para ficheiros shadow e PAM

tzdata
Fontes de datos do fuso horario e do horario de verán

nano
Pico editor clon con melloras

Ademais, pode instalar soporte nas páxinas man do sistema instalando os seguintes paquetes − man man-pages mdocml-apropos less

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

Vexamos os comandos e teclas que usamos:

  • lxc — Chamar ao cliente LXD
  • exec - Método cliente LXD que executa un comando no contedor
  • jupyterlab - ID do recipiente
  • -- - Unha chave especial que especifica non interpretar máis chaves como claves para lxc e pasar o resto da corda tal e como está ao recipiente
  • apk — Xestor de paquetes de distribución de Alpine Linux
  • add — Un método de xestor de paquetes que instala os paquetes especificados despois do comando

A continuación, estableceremos unha zona horaria no sistema Europe/Moscow:

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

Despois de instalar o fuso horario, o paquete tzdata xa non é necesario no sistema, ocupará espazo, así que imos borralo:

lxc exec jupyterlab -- apk del tzdata

Comprobando o fuso horario:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Para non gastar moito tempo configurando Bash para novos usuarios no contedor, nos seguintes pasos copiaremos ficheiros skel preparados do sistema host a el. Isto permitirache adornar Bash nun contedor de forma interactiva. O meu sistema host é Manjaro Linux e os ficheiros que se están copiando /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors en principio son axeitados para Alpine Linux e non causan problemas críticos, pero pode que teña unha distribución diferente e teña que descubrir de forma independente se hai un erro ao executar Bash no contedor.

Copia os ficheiros skel no contedor. Chave --create-dirs creará os directorios necesarios se non existen:

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

Para un usuario root xa existente, copie os ficheiros skel que se acaban de copiar no contedor no directorio de inicio:

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 instala un shell do sistema para os usuarios /bin/sh, substituirémolo por root usuario en Bash:

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

Que root o usuario non tiña contrasinal, necesita establecer un contrasinal. O seguinte comando xerará e establecerá un novo contrasinal aleatorio para el, que verá na pantalla da consola despois da súa execución:

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

Ademais, imos crear un novo usuario do sistema - jupyter para o que configuraremos máis adiante laboratorio jupyter:

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

Imos xerar e establecer un contrasinal para el:

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

A continuación, executaremos dous comandos, o primeiro creará un grupo de sistema sudo, e o segundo engadiralle un usuario jupyter:

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

Vexamos a que grupos pertence o usuario jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Todo está ben, sigamos.

Permitir a todos os usuarios que sexan membros do grupo sudo usar comando sudo. Para iso, execute o seguinte script, onde sed descomenta a liña de parámetros no ficheiro de configuración /etc/sudoers:

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

Instalación e configuración de JupyterLab ^

laboratorio jupyter é unha aplicación de Python, polo que primeiro debemos instalar este intérprete. Ademais, laboratorio jupyter instalaremos usando o xestor de paquetes Python pip, e non o do sistema, porque pode estar desactualizado no repositorio do sistema e, polo tanto, temos que resolver manualmente as dependencias instalando os seguintes paquetes: python3 python3-dev gcc libc-dev zeromq-dev:

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

Imos actualizar os módulos de Python e o xestor de paquetes pip á versión actual:

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

Conxunto laboratorio jupyter a través do xestor de paquetes pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Desde as extensións en laboratorio jupyter son experimentais e non se envían oficialmente co paquete jupyterlab, polo que temos que instalalo e configuralo manualmente.

Imos instalar NodeJS e o xestor de paquetes para iso - NPM, xa que laboratorio jupyter utilízaos para as súas extensións:

lxc exec jupyterlab -- apk add nodejs npm

Ás extensións para laboratorio jupyter que instalaremos funcionaron, deben estar instaladas no directorio de usuarios xa que a aplicación lanzarase dende o usuario jupyter. O problema é que non hai ningún parámetro no comando de lanzamento que se poida pasar a un directorio, a aplicación só acepta unha variable de ambiente e por iso debemos definila. Para iso, escribiremos o comando de exportación variable JUPYTERLAB_DIR no contorno do usuario jupyter, para arquivar .bashrcque se executa cada vez que o usuario inicia sesión:

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

O seguinte comando instalará unha extensión especial: o xestor de extensións laboratorio 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"

Agora todo está listo para o primeiro lanzamento laboratorio jupyter, pero aínda podemos instalar algunhas extensións útiles:

  • toc — Índice, xera unha lista de títulos nun artigo/caderno
  • jupyterlab-horizon-theme - Tema da IU
  • jupyterlab_neon_theme - Tema da IU
  • jupyterlab-ubu-theme - Outro tema do autor este artigo :) Pero neste caso, amosarase a instalación desde o repositorio de GitHub

Entón, execute os seguintes comandos secuencialmente para instalar estas extensións:

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"

Despois de instalar as extensións, debemos compilalas, xa que previamente, durante a instalación, especificamos a clave --no-build para aforrar tempo. Agora aceleraremos significativamente recompilándoos dunha soa vez:

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

Agora executa os dous comandos seguintes para executalo por primeira vez laboratorio jupyter. Sería posible lanzalo cun só comando, pero neste caso, o comando de inicio, que é difícil de lembrar na túa mente, lembrarase mediante bash no contedor e non no host, onde xa hai suficientes comandos. para gravalos na historia :)

Inicie sesión no contedor como usuario jupyter:

lxc exec jupyterlab -- su -l jupyter

A continuación, corre laboratorio jupyter coas teclas e parámetros indicados:

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

Vaia ao enderezo no seu navegador web http://10.0.5.5:8888 e na páxina que se abre entra símbolo acceso que verás na consola. Copia e pégao na páxina e fai clic Iniciar sesión. Despois de iniciar sesión, vai ao menú de extensións da esquerda, como se mostra na figura seguinte, onde se lle solicitará, ao activar o xestor de extensións, que asuma os riscos de seguridade instalando extensións de terceiros para as que o comando Desenvolvemento de JupyterLab non é responsable:

Lanzamento de Jupyter na órbita LXD

Non obstante, illamos a totalidade laboratorio jupyter e colócao nun contedor para que as extensións de terceiros que requiran e utilicen NodeJS non poidan, polo menos, roubar datos do disco que non sexan os que abrimos dentro do contedor. Accede aos teus documentos privados no host en /home É improbable que os procesos do contenedor teñan éxito e, se o fan, terás que ter privilexios nos ficheiros do sistema host, xa que executamos o contedor en modo sen privilexios. En función desta información, podes avaliar o risco de incluír extensións laboratorio jupyter.

Creáronse cadernos IPython (páxinas en laboratorio jupyter) agora crearase no directorio de inicio do usuario - /home/jupyter, pero os nosos plans son dividir os datos (compartir) entre o host e o contedor, así que volve á consola e detén laboratorio jupyter executando a tecla de acceso rápido - CTRL+C e respondendo y baixo pedido. A continuación, finaliza a sesión interactiva do usuario jupyter completando unha tecla de acceso rápido CTRL+D.

Compartir datos co host ^

Para compartir datos co host, cómpre crear un dispositivo no contedor que che permita facelo e para iso, executa o seguinte comando onde especificamos as seguintes claves:

  • lxc config device add — O comando engade a configuración do dispositivo
  • jupyter — ID do contedor ao que se engade a configuración
  • hostfs - ID do dispositivo. Podes establecer calquera nome.
  • disk — Indícase o tipo de dispositivo
  • path — Especifica a ruta do contedor no que LXD montará este dispositivo
  • source — Especifique a orixe, o camiño ao directorio do host que quere compartir co contedor. Especifique o camiño segundo as súas preferencias
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Para o catálogo /home/dv/projects/ipython-notebooks o permiso debe establecerse para o usuario do contedor que actualmente ten un UID igual a SubUID + UID, ver capítulo Seguridade. Privilexios de contedores no artigo Características básicas dos sistemas de contedores LXD - Linux.

Establece o permiso no host, onde o propietario será o usuario do contedor jupyter, e a variable $USER especificará o seu usuario anfitrión como grupo:

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

Ola, mundo! ^

Se aínda tes unha sesión de consola aberta no contedor con laboratorio jupyter, despois reinicia cunha nova chave --notebook-dir establecendo o valor /mnt/hostfs como o camiño ata a raíz dos portátiles no contedor do dispositivo que creamos no paso anterior:

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

Despois vai á páxina http://10.0.5.5:8888 e crea o teu primeiro portátil facendo clic no botón da páxina como se mostra na imaxe de abaixo:

Lanzamento de Jupyter na órbita LXD

Despois, no campo da páxina, introduza o código Python que mostrará o clásico Hello World!. Cando remate de ingresar, prema CTRL+ENTER ou o botón "reproducir" na barra de ferramentas da parte superior para que JupyterLab faga isto:

Lanzamento de Jupyter na órbita LXD

Neste punto, case todo está listo para o seu uso, pero non será interesante se non instalamos módulos adicionais de Python (aplicacións completas) que poidan ampliar significativamente as capacidades estándar de Python en laboratorio jupyterpolo tanto, sigamos :)

PD O interesante é que a antiga implementación Xúpiter baixo o nome de código Caderno Jupyter non desapareceu e existe paralelamente laboratorio jupyter. Para cambiar á versión antiga, siga a ligazón engadindo o sufixo no enderezo/tree, e a transición á nova versión realízase co sufixo /lab, pero non hai que especificalo:

Ampliación das capacidades de Python ^

Nesta sección, instalaremos módulos de linguaxe Python tan poderosos como numpy, pandas, matplotlib, IPyWidgets cuxos resultados están integrados en portátiles laboratorio jupyter.

Antes de instalar os módulos de Python listados a través do xestor de paquetes pip primeiro debemos resolver as dependencias do sistema en Alpine Linux:

  • g++ — Necesario para compilar módulos, xa que algúns deles están implementados na linguaxe C ++ e conéctese a Python en tempo de execución como módulos binarios
  • freetype-dev - dependencia para o módulo Python matplotlib

Instalación de dependencias:

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

Hai un problema: no estado actual da distribución Alpine Linux, non será posible compilar a nova versión de NumPy; aparecerá un erro de compilación que non puiden resolver:

ERROR: Non se puideron construír rodas para numpy que usan PEP 517 e non se poden instalar directamente

Polo tanto, instalaremos este módulo como un paquete do sistema que distribúe unha versión xa compilada, pero un pouco máis antiga que a que está dispoñible actualmente no sitio:

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

A continuación, instale os módulos de Python a través do xestor de paquetes pip. Ten paciencia xa que algúns módulos compilaranse e poden tardar uns minutos. Na miña máquina, a compilación levou ~15 minutos:

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

Borrar cachés de instalación:

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

Probando módulos en JupyterLab ^

Se estás correndo laboratorio jupyter, reinicialo para que se activen os módulos recén instalados. Para iso, nunha sesión de consola, fai clic CTRL+C onde o teñas funcionando e entra y para deter a solicitude e comezar de novo laboratorio jupyter premendo a frecha cara arriba do teclado para non volver a introducir o comando e despois Enter para comezalo:

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

Vaia á páxina http://10.0.5.5:8888/lab ou actualice a páxina no seu navegador e, a continuación, introduza o seguinte código nunha nova cela do caderno:

%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

Debería obter un resultado como na imaxe de abaixo, onde IPyWidgets xera un elemento de IU na páxina que interactúa de forma interactiva co código fonte, e tamén matplotlib mostra o resultado do código en forma de imaxe como un gráfico de funcións:

Lanzamento de Jupyter na órbita LXD

Moitos exemplos IPyWidgets podes atopalo nos tutoriais aquí

Que máis? ^

Ben feito se quedaste e chegaches ao final do artigo. Non publiquei deliberadamente un script preparado ao final do artigo que se instalaría laboratorio jupyter en "un clic" para animar aos traballadores :) Pero podes facelo ti mesmo, xa que xa sabes como, despois de reunir os comandos nun único script Bash :)

Tamén podes:

  • Establece un nome de rede para o contedor en lugar dun enderezo IP escribindoo nun sinxelo /etc/hosts e escriba o enderezo no navegador http://jupyter.local:8888
  • Xoga co límite de recursos para o contedor, para iso le o capítulo en capacidades básicas de LXD ou obtén máis información no sitio para desenvolvedores de LXD.
  • Cambia o tema:

Lanzamento de Jupyter na órbita LXD

E moito máis podes facer! Iso é todo. Deséxoche éxito!

ACTUALIZACIÓN: 15.04.2020/18/30 XNUMX:XNUMX - Corrixiron erros no capítulo "Ola, mundo!"
ACTUALIZACIÓN: 16.04.2020/10/00 XNUMX:XNUMX — Texto corrixido e engadido na descrición da activación do xestor de extensións laboratorio jupyter
ACTUALIZACIÓN: 16.04.2020/10/40 XNUMX:XNUMX — Corrixíronse os erros atopados no texto e cambiou lixeiramente para mellor o capítulo "Instalación de software básico e configuración do sistema"

Fonte: www.habr.com

Engadir un comentario