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.
- La procédure est résumée en fonction du journal au moment de la construction de l'environnement, mais il peut y avoir des omissions telles que les paramètres d'autorisation. Si vous essayez de le reproduire et que cela ne fonctionne pas bien, veuillez nous le faire savoir dans les commentaires. De plus, je pense qu'il existe une procédure de construction d'environnement plus élégante, donc s'il y en a aussi, ...
Flux de fonctionnement
En gros, cela ressemble à ce qui suit.
- Accédez à http://jupyter.example.jp/ (il est préférable d'ajouter une authentification BASIC, etc.)
- nginx est traité et proxy vers JupyterHub fonctionnant à 127.0.0.1:8000
- Vous pouvez utiliser Jupyter Notebook en vous authentifiant avec GitHub
- 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.
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.
- J'utilise Sudo Spawner cette fois, mais il y en a peut-être plus qui conviennent.
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
- Il est nécessaire de définir le nom d'utilisateur Linux = le nom d'utilisateur GitHub, donc je serais heureux si je pouvais créer une logique de mappage, mais cela ne prend pas beaucoup en charge.
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
- Je pense que les variables d'environnement devraient être exclues, mais ...
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.
- GitHub est ** g_hoge **, Linux est ** l_hoge ** Ce serait idéal si vous pouviez mapper ** g_hoge ** → ** l_hoge ** quand il y a un utilisateur, mais ce n'est pas le cas. Hmm.
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
- Comme ipython n'est pas installé dans l'environnement racine, j'ai enregistré celui créé dans l'environnement Virtualenv à l'emplacement requis.
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
- Vous parlez de la fraîcheur du notebook Jupyter.
- Powerful Notepad for Modern Engineers Jupyter notebook recommendation TC'est agréable et arbitraire, mais vous pouvez ressentir l'amour pour le notebook Jupyter.
- Environnement de codage recommandé Jupyter Notebook pour les data scientists
Recommended Posts