Créer un environnement d'analyse de données qui relie l'authentification GitHub et Django avec JupyterHub

introduction

JupyterHub est un mécanisme pour faire fonctionner Python etc. sur un navigateur WEB appelé Jupyter Notebook. C'est un mécanisme pour le rendre disponible dans, mais comme il n'y avait aucune information fragmentée mais organisée, comme la connexion à l'aide de l'authentification GitHub et une bonne connexion avec l'environnement Shell de Django, cela est résumé. Nous utilisons ELB / EC2 / RDS d'AWS et nginx pour le serveur Web.

Comme cas d'utilisation, j'ai déjà construit un environnement Django pour me connecter aux données de test, mais je veux un environnement où je peux le toucher rapidement à partir du WEB · Je veux séparer l'environnement pour chaque utilisateur mais créer un mécanisme d'authentification compliqué Je pense que c'est utile quand on ne veut pas s'ennuyer.

Une fois terminé, vous pourrez effectuer rapidement les opérations suivantes sur le navigateur WEB. スクリーンショット 2017-02-19 15.47.47.png

Flux de fonctionnement

En gros, cela ressemble à ce qui suit.

  1. Accédez à http://jupyter.example.jp/ (il est préférable d'ajouter une authentification BASIC, etc.)
  2. nginx est traité et proxy vers JupyterHub fonctionnant à 127.0.0.1:8000
  3. Vous pouvez utiliser Jupyter Notebook en vous authentifiant avec GitHub
  4. Jupyter Notebook fonctionne comme un noyau en se connectant aux processus Django, vous pouvez donc accéder immédiatement à la base de données.

Problème restant: l'environnement SSL n'a pas été créé

Je pense qu'il existe un moyen de le faire, mais si vous utilisez une connexion https, lorsque vous configurez SSL → nginx → Tornade sur Virtualenv à JupyterHub, il échouera à se connecter lorsque vous le spécifiez comme noyau de Django dans notebook. J'ai fait. L'accès à http est correct, mais il semble que quelque chose d'autre doit être défini, il est peut-être nécessaire de dire à JupyterHub qu'il s'agit de http en interne. Puisqu'il y a un accès de l'extérieur comme une coopération avec GitHub, cela devrait être https, mais il est un peu décevant qu'il n'ait pas atteint ce point.

Procédure de construction de l'environnement

structure globale

Dans l'environnement que j'utilise, la base de données du serveur de production est masquée avec Daily et stockée dans un autre RDS. Dans l'environnement de test / staging, la base de données de masque peut être exploitée depuis Django. Dans ce document, l'objectif est de permettre à l'environnement exploité par Django pour le RDS d'être exécuté via Jupyter Hub.

JupyterHub全体構成

Hypothèses environnementales

/ var / www / jupyter.example.jp / On suppose que l'environnement Django est construit sous. Certaines des structures de répertoires qui peuvent être pertinentes sont présentées ci-dessous.

/var/www/jupyter.example.jp/
├── README.md
├── jupyter  #Placer le code d'application(Ci-dessous, gérer.Il y a py)
├── requirements.txt
├── virtualenv

Nous partons du principe que Django est déjà inclus dans l'environnement virtualenv et que django-extensions est inclus pour charger le modèle en utilisant shell_plus.

L'environnement virtualenv est inclus comme suit.

cd /var/www/jupyter.example.jp/
virtualenv --prompt "(jupyter)" virtualenv

Placez également le fichier de configuration JupyterHub sous / etc / jupyterhub.

Créer un utilisateur pour JupyterHub

JupyterHub est géré par l'utilisateur jupyterhub.

sudo useradd jupyterhub
sudo usermod -a -G shadow jupyterhub
sudo mkdir /etc/jupyterhub
sudo chown jupyterhub /etc/jupyterhub

Installez Jupyter Hub

Continuez avec jupyterhub / jupyterhub: serveur multi-utilisateur pour notebooks Jupyter.

sudo apt-get install npm nodejs-legacy
sudo npm install -g configurable-http-proxy
(Installer avec pip sous environnement virtualenv)
pip install ipython jupyterhub

(Comment installer npm et node, tout en se sentant vieux)

Création d'un fichier de configuration JupyterHub

jupyterhub --generate-config
/etc/jupyterhub/jupyterhub_config.Accédez à py et corrigez ce qui suit

L.Près de 137
c.JupyterHub.ip = '127.0.0.1'

L.Près de 106
c.JupyterHub.cookie_secret_file = '/etc/jupyterhub/jupyterhub_cookie_secret'
c.JupyterHub.db_url = '/etc/jupyterhub/jupyterhub.sqlite'

Référence: http://jupyterhub.readthedocs.io/en/latest/config-examples.html

Connectez-vous avec un compte GitHub

Créez des paramètres pour vous connecter à GitHub avec Oauth depuis JupyterHub.

pip install oauthenticator

Ajout de ce qui suit à environ L.58 de jupyterhub_config.py

c.JupyterHub.authenticator_class = 'oauthenticator.GitHubOAuthenticator'
c.GitHubOAuthenticator.oauth_callback_url = os.environ['OAUTH_CALLBACK_URL']
c.GitHubOAuthenticator.client_id = os.environ['GITHUB_CLIENT_ID']
c.GitHubOAuthenticator.client_secret = os.environ['GITHUB_CLIENT_SECRET']

Référence: https://github.com/jupyterhub/oauthenticator

Spawner Je n'ai pas une compréhension approfondie de ce qu'est Spawner, mais il semble que j'ai besoin de définir un Spawner pour JupyterHub pour gérer le processus.

Référence: http://jupyterhub.readthedocs.io/en/latest/spawners.html

pip install git+https://github.com/jupyter/sudospawner

Décrivez ce qui suit près de L.220 de jupyterhub_config.py

c.JupyterHub.confirm_no_ssl = True
c.JupyterHub.spawner_class = 'sudospawner.SudoSpawner'
c.Spawner.notebook_dir = '~/notebooks'

c.SudoSpawner.sudospawner_path = '/var/www/jupyter.example.jp/virtualenv/bin/sudospawner'

Ajoutez ce qui suit à la fin avec sudo visudo.

## Jupyterhub
# comma-separated whitelist of users that can spawn single-user servers
Runas_Alias JUPYTER_USERS =Nom d'utilisateur GitHub à utiliser(Séparé par des virgules)

# the command(s) the Hub can run on behalf of the above users without needing a password# the exact pa$
Cmnd_Alias JUPYTER_CMD = /var/www/jupyter.example.jp/virtualenv/bin/sudospawner

# actually give the Hub user permission to run the above command on behalf# of the above users without$
jupyterhub ALL=(JUPYTER_USERS) NOPASSWD:JUPYTER_CMD

Référence: http://qiita.com/mt08/items/301f9fb93d01e78bda47

Démarrez Jupyter Hub

Avec les paramètres jusqu'à ce point, vous pouvez démarrer le serveur JupyterHub. Créez un script de démarrage et démarrez-le.

sudo -u jupyterhub vi /etc/jupyterhub/launch_notebook.sh
#!/bin/bash

export OAUTH_CALLBACK_URL=http://jupyter.example.jp/hub/oauth_callback
export GITHUB_CLIENT_ID=xxx
export GITHUB_CLIENT_SECRET=xxx

source /var/www/jupyter.example.jp/virtualenv/bin/activate
jupyterhub -f /etc/jupyterhub/jupyterhub_config.py

CLIENT_ID et CLIENT_SECRET requis pour l'intégration GitHub peuvent être obtenus à partir de ce qui suit. https://github.com/settings/applications/new

avec ça

sudo -u jupyterhub /etc/jupyterhub/launch_notebook.sh

Si vous exécutez, JupyterHub devrait démarrer à http://127.0.0.1:8000/.

paramètres nginx

Une fois que JupyterHub démarre, nous enverrons ensuite l'accès depuis ELB. nginx reçoit l'accès au port 80 et l'utilise comme proxy pour envoyer au port 8000 s'il doit être traité par JupyterHub.

sudo vi vi /etc/nginx/nginx.conf
http {
    map $http_upgrade $connection_upgrade {
        default upgrade;
        ''      close;
    }
    ...

Créez un fichier de configuration décrivant les paramètres de jupyter.example.jp sous / etc / nginx / sites-enabled /. (Exemple: jupyter.example.jp.conf)

server {
    listen 80;
    server_name jupyter.example.jp;

    #Je souhaite activer les paramètres suivants lors de la création d'un environnement de connexion HTTPS
    # add_header Strict-Transport-Security max-age=15768000;

    # Managing literal requests to the JupyterHub front end
    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    # Managing WebHook/Socket requests between hub user servers and external proxy
    location ~* /(api/kernels/[^/]+/(channels|iopub|shell|stdin)|terminals/websocket)/? {
        proxy_pass http://127.0.0.1:8000;

        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        # WebSocket support
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
    }
}

Vous permettre de vous connecter via GitHub

Si vous avez déjà le même nom d'utilisateur GitHub pour les utilisateurs Linux, il n'y a pas de problème, mais si vous ne l'avez pas, vous devez le créer.

USER=Nom d'utilisateur GitHub à utiliser
useradd -d /home/${USER} -m ${USER}
mkdir /home/${USER}/notebooks
chown ${USER}/home/${USER}/notebooks

Paramètres du noyau

Le bloc-notes Jupyter a le concept de ** Kernel **, qui vous permet de spécifier l'environnement Python à utiliser lors de l'exécution. Par défaut, il s'agit de l'environnement Python au démarrage, mais en définissant l'environnement à l'aide du shell_plus de Django sur ceci, c'est très pratique car il peut être utilisé avec la base de données déjà connectée et l'importation du modèle terminée.

Si vous avez Jupyter Hub dans votre environnement Virtualenv, vous pouvez créer un fichier de configuration avec: AVERTISSEMENT est sorti, mais ...

% jupyter kernelspec install-self --user
[InstallNativeKernelSpec] WARNING | `jupyter kernelspec install-self` is DEPRECATED as of 4.0. You probably want `ipython kernel install` to install the IPython kernelspec.
[InstallNativeKernelSpec] Installed kernelspec python3 in /home/your_user/.local/share/jupyter/kernels/python3

Si vous le placez dans la zone globale sans le mettre dans l'environnement Virtualenv, vous pourrez peut-être le faire comme suit.

% python -m ipykernel install
Installed kernelspec python3 in /usr/local/share/jupyter/kernels/python3

Ensuite, déplacez les fichiers de paramètres créés.

% cd /usr/local/share
% sudo mv /home/your_user/.local/share/jupyter ./
% sudo chmod 775 jupyter
% sudo chown -R root:root jupyter
% cd /usr/local/share/jupyter/kernels

% ls /usr/local/share/jupyter/kernels
python3

% sudo mv python3 django

% ls /usr/local/share/jupyter/kernels/django
kernel.json  logo-32x32.png  logo-64x64.png
sudo vi django/kernel.json

Je pense que c'est comme suit, alors modifiez-le comme décrit plus tard.

{
 "language": "python",
 "argv": [
  "/var/www/jupyter.example.jp/virtualenv/bin/python3.4",
  "-m",
  "ipykernel",
  "-f",
  "{connection_file}"
 ],
 "display_name": "Python 3"
}

{
  "display_name": "Django",
  "language": "python",
  "codemirror_mode": {
    "version": 3,
    "name": "ipython"
  },
  "argv": [
    "/var/www/jupyter.example.jp/virtualenv/bin/python",
    "/var/www/jupyter.example.jp/jupyter/manage.py",
    "shell_plus",
    "--settings=jupyter.settings",
    "--kernel",
    "--connection-file",
    "{connection_file}"
  ]
}

※--settings=jupyter.les paramètres sont gérer.Spécifiez le chemin du fichier de configuration Django utilisé par py
※shell_Django vers Django pour utiliser plus-INSTALLÉ avec des extensions_Django sur APPS_les extensions doivent être spécifiées

Référence 1: https://ipython.org/ipython-doc/3/development/kernels.html Référence 2: http://stackoverflow.com/questions/31088080/django-extensions-shell-plus-kernel-specify-connection-file (Il doit s'agir de "--connection-file" comme mentionné dans le commentaire) Référence 3: http://stackoverflow.com/questions/39007571/running-jupyter-with-multiple-python-and-ipython-paths

Aussi, https://github.com/Cadair/jupyter_environment_kernels Il peut être plus facile de changer de noyau en insérant ceci, mais je ne l'ai pas fait.

Gérer Jupyter Hub avec superviseur

Vous pouvez maintenant le démarrer en exécutant launch_notebook.sh, mais comme il est difficile de le démarrer à chaque redémarrage du serveur, laissez Supervisord le démarrer automatiquement.

sudo vi /etc/supervisor/conf.d/
[program:notebook]
command=/etc/jupyterhub/launch_notebook.sh
directory=/etc/jupyterhub/
autostart=true
autorestart=true
stopgroup=true
startretries=3
exitcodes=0,2
stopsignal=TERM
user=jupyterhub
group=jupyterhub

Lisez le fichier de configuration et démarrez-le.

supervisord reread
supervisord reload
supervisord start notebook

Il démarrera automatiquement et le journal sera répertorié dans / etc / log / supervisor / notebook-xxx.log.

Appendix Je vais résumer le contenu que j'ai obtenu lors de la construction de l'environnement et les liens auxquels j'ai fait référence.

problème de connection_upgrade

Si vous envoyez 80e accès à JupyterHub sans y penser,

2017/02/03 17:20:44 [emerg] 16297#16297: unknown "connection_upgrade" variable

J'obtiens l'erreur.

Il a été résolu en se référant à http://mogile.web.fc2.com/nginx/http/websocket.html, mais il semble qu'il soit nécessaire de décrire ce qui suit dans / etc / nginx / nginx.conf.

http {
    map $http_upgrade $connection_upgrade {
        default upgrade;
        ''      close;
    }

Erreur lors de la connexion à https

Si vous accédez à partir de https avec ELB, vous pouvez accéder à JupyterHub, mais lorsque vous configurez Kernel, l'erreur suivante apparaît dans Supervisord.

[I 2017-02-05 21:43:24.410 JupyterHub log:100] 200 GET /hub/api/authorizations/cookie/jupyter-hub-token-xxx/[secret]([email protected]) 14.89ms
21:44:26.703 - error: [ConfigProxy] Proxy error:  Error: socket hang up
    at createHangUpError (http.js:1472:15)
    at Socket.socketCloseListener (http.js:1522:23)
    at Socket.EventEmitter.emit (events.js:95:17)
    at TCP.close (net.js:466:12)

Cela s'appelle un cookie, et il semble qu'il puisse être guéri en modifiant la valeur de réglage quelque part, mais je n'ai pas pu le faire et j'ai abandonné. J'essaierai encore un jour.

Installer diverses bibliothèques pour l'analyse des données

Cette zone est publiée ailleurs, elle peut donc être omise, mais pour utiliser matplotlib etc., les bibliothèques nécessaires à l'analyse des données sont incluses dans ce qui suit.

sudo apt-get install -y libpng12-dev libjpeg8-dev libfreetype6-dev libxft-dev
pip install numpy pandas matplotlib seaborn scikit-learn
* Vous pouvez l'utiliser en le mettant dans l'environnement virtualenv et en l'utilisant comme cahier de redémarrage superviseur.

Autres matériaux de référence

Recommended Posts

Créer un environnement d'analyse de données qui relie l'authentification GitHub et Django avec JupyterHub
Créez un environnement d'analyse de données avec Kedro + MLflow + Github Actions
[DynamoDB] [Docker] Créer un environnement de développement pour DynamoDB et Django avec docker-compose
[Python] Créer un environnement de développement Django avec Docker
Créez un environnement Django avec Vagrant en 5 minutes
Créez un environnement virtuel avec pyenv et venv
Créer un environnement de développement Django à l'aide de Doker Toolbox
Créez rapidement un environnement Python Django avec IntelliJ
Créez un environnement virtuel python avec virtualenv et virtualenvwrapper
Créez un environnement virtuel python avec virtualenv et virtualenvwrapper
Créez un environnement de développement avec Poetry Django Docker Pycharm
Construire un environnement Django pour Win10 (avec espace virtuel)
Construire un environnement de calcul numérique avec pyenv et miniconda3
Développer une API Web qui renvoie les données stockées dans DB avec Django et SQLite
Créez un environnement de développement Django avec Docker! (Docker-compose / Django / postgreSQL / nginx)
Créer un environnement Docker qui peut utiliser PyTorch et JupyterLab
Créez un environnement d'apprentissage automatique scikit-learn avec VirtualBox et Ubuntu
[Django] Créez rapidement un environnement de développement de conteneur Django (Docker) avec PyCharm
Créer un environnement d'analyse de données python sur Mac (El Capitan)
Créer un environnement Python et transférer des données vers le serveur
Créer une application Todo avec Django ① Créer un environnement avec Docker
Créer une application Web avec Django
Créez un environnement Python 2.7 64 bits avec TDM-GCC et MinGW-w64 sous Windows 7
Créez un environnement Python sur votre Mac avec Anaconda et PyCharm
Créez un environnement d'expérimentation / d'analyse psychologique confortable avec PsychoPy + Jupyter Notebook
Créer un Ubuntu de démarrage USB avec un environnement Python pour l'analyse des données
Créer un environnement Tensorflow avec Raspberry Pi [2020]
Créez un environnement d'API rapide avec docker-compose
Créez un environnement CentOS Linux 8 avec Docker et démarrez Apache HTTP Server
[Linux] Créer un environnement Jenkins avec Docker
Créez rapidement un environnement python pour le Deep Learning / Data Science (Windows)
Créez un environnement virtuel pour python avec pyenv
Construisez un environnement de simulateur de drone et essayez un vol simple avec Mission Planner
Créez un environnement Python moderne avec Neovim
Procédure de création d'un environnement Django avec Win10 WSL Ubuntu18.04 + Anaconda + Apache2
[Linux] Construction de l'environnement Docker avec Amazon Linux 2
Construisez un environnement Python + bouteille + MySQL avec Docker sur RaspberryPi3! [Essai et erreur]
Essayez de créer une application Web avec Vue.js et Django (édition Mac) - (1) Construction d'environnement, création d'application
Créer un environnement de développement TensorFlow sur Amazon EC2 avec une copie de commande
Pratique de création d'une plateforme d'analyse de données avec BigQuery et Cloud DataFlow (traitement de données)
Création d'un environnement distribué avec la série Raspberry PI (Partie 3: Installation et configuration de dnsmasq)
Créer un environnement de développement de langage C avec un conteneur
Créez un environnement WardPress sur AWS avec Pulumi
Préparer un environnement de langage de programmation pour l'analyse des données
Construire un environnement python avec virtualenv et direnv
Construire un environnement Django sur Raspai (MySQL)
Créez un environnement python avec ansible sur centos6
Démarrez Django dans un environnement virtuel à l'aide de Pipenv
Créer un environnement de construction python3 avec Sublime Text3
[Memo] Créez un environnement virtuel avec Pyenv + anaconda
Construire un environnement Python avec OSX Elcapitan
Créer un environnement d'apprentissage automatique Python avec des conteneurs
Créer un environnement d'exécution python avec VS Code
Obtenez une grande quantité de données Twitter de Starba avec python et essayez l'analyse de données Partie 1
Créez rapidement un tableau de bord d'analyse de données Python avec Streamlit et déployez-le sur AWS
Créez un environnement de science des données de base (Jupyter, Python, R, Julia, bibliothèque standard) avec Docker.
[AWS] J'ai essayé de créer un environnement Python avec un environnement de développement eb [Elastic Beanstalk]
Créez un environnement python pour chaque répertoire avec pyenv-virtualenv