Procédure d'attachement et de débogage de VS Code vers Jupyter Lab sur un serveur distant

1. Que faut-il expliquer dans cet article

Suivez les étapes ci-dessous pour créer un environnement de débogage à l'aide de Jupyter Lab et VS Code.

  1. Lancez Jupyter Lab sur un serveur distant
  2. Appelez une classe Python depuis JupyterLab.
  3. Attachez à distance au bloc-notes JupyterLab ci-dessus à partir de VSCode sur le PC local pour déboguer.
  4. La figure est la suivante.
スクリーンショット 2020-04-08 00.09.27.png

Si vous regardez la vidéo ci-dessous, vous pouvez avoir une idée de ce que vous pouvez faire. Untitled.gif

  1. Motivation
  2. JupyterLab est pratique pour écrire un peu de code et partager les résultats parfaitement ensemble, mais lors de la création d'un programme sérieusement, vous utilisez probablement un éditeur tel que VSCode.
  3. Par contre, lors de la vérification à l'aide du programme développé de cette manière, il est souvent pratique de l'appeler depuis JupyterLab.
  4. Dans cet usage, nous expliquerons comment définir un point d'arrêt sur le programme appelé depuis JupyterLab et créer un environnement pour le débogage à partir de VS Code.

3. Points de l'environnement à construire cette fois

Dans VS Code, en utilisant un mécanisme appelé développement à distance, vous pouvez modifier les dossiers et les fichiers sur le serveur distant presque de la même manière que sur votre PC local en vous connectant avec ssh. Voir ici pour plus de détails. --VS Code vous permet d'attacher et de déboguer des processus Python sur le serveur distant en installant un package appelé ptvsd sur le serveur distant. Voir ici pour plus de détails.

4. Construction de l'environnement

4.1. Construction d'un environnement de serveur distant

4.1.1. Prérequis

4.1.2. Installation des applications requises

# apt-get update
# apt-get install -y wget
# apt-get install -y language-pack-ja
# apt-get install -y ssh
# apt-get install -y git
# update-locale LANG=ja_JP.UTF-8

4.1.3. Installation de nodejs

Requis pour installer l'extension JupyterLab. Cette étape n'est pas nécessaire si vous souhaitez simplement définir le noyau, mais il est préférable de la prendre en charge pour une utilisation pratique de Jupyter Lab.

# curl -sL https://deb.nodesource.com/setup_12.x | bash -
# apt-get install -y nodejs

4.1.4. Installer Python et Jupyter Lab

# pip install -r requirements.txt

requirements.txt


numpy==1.16.3
matplotlib==3.0.3
scikit_learn==0.20.3
jupyterlab==1.0.2
ptvsd==4.3.2

4.1.5. Démarrez ssh pour accéder à partir de VS Code côté PC local

Requis pour se connecter à un serveur distant à partir de VS Code pour le développement à distance. Cette fois, ouvrez le port ssh sur le port 19205.

# cp /etc/ssh/sshd_config /etc/ssh/sshd_config.org
# sed -e s/#Port/Port/g /etc/ssh/sshd_config.org  | sed -e s/22/19205/g > /etc/ssh/sshd_config

Ensuite, démarrez ssh.

root@25fa703a90c4:/tf# service ssh start
 * Starting OpenBSD Secure Shell server sshd                             [ OK ]

4.2. Paramètres de Jupyter Lab

Ensuite, configurez Jupyter Lab. Cette fois, nous allons démarrer le serveur jupyterLab en tant qu'utilisateur jupyter.

4.2.1. Modifier la propriété du répertoire / usr / local / share / jupyter / lab

Tout d'abord, en préparation, changez la propriété du répertoire / usr / local / share / jupyter / lab en jupyter. Si vous ne le faites pas, vous ne pourrez pas installer les extensions de JupyterLab au démarrage en tant qu'utilisateur jupyter, ce qui n'est pas pratique. Je pense qu'il existe un meilleur moyen (par exemple, conservez ces fichiers dans votre répertoire personnel). Ici, je vais changer la propriété facilement ci-dessous.

# chown -R jupyter:jupyter /usr/local/share/jupyter/lab

4.2.2. Définir ptvsd comme noyau de Jupyter Lab

Tout d'abord, enregistrez le fichier suivant sous le nom de fichier /usr/local/share/jupyter/kernels/ptvsd/kernel.json afin de pouvoir appeler l'interpréteur pour le débogage depuis JupyterLab. (La méthode d'appel de l'interpréteur défini ici à partir de JupyterLab sera expliquée plus tard.)

kernel.json


{
 "argv": [
  "/usr/bin/python3",
  "-m",
  "ptvsd",
  "--host",
  "0.0.0.0",
  "--port",
  "19204",
  "-m",
  "ipykernel_launcher",
  "-f",
  "{connection_file}"
 ],
 "display_name": "Python3 Debug",
 "language": "python"
}

C'est comme ça.

root@25fa703a90c4:/usr/local/share/jupyter/kernels# pwd
/usr/local/share/jupyter/kernels
root@25fa703a90c4:/usr/local/share/jupyter/kernels# mkdir ptvsd
root@25fa703a90c4:/usr/local/share/jupyter/kernels# cd ptvsd
root@25fa703a90c4:/usr/local/share/jupyter/kernels/ptvsd# cat > kernel.json <<EOL
{
 "argv": [
  "/usr/bin/python3",
  "-m",
  "ptvsd",
  "--host",
  "0.0.0.0",
  "--port",
  "19204",
  "-m",
  "ipykernel_launcher",
  "-f",
  "{connection_file}"
 ],
 "display_name": "Python3 Debug",
 "language": "python"
}
EOL
root@25fa703a90c4:/usr/local/share/jupyter/kernels/ptvsd# ls kernel.json
kernel.json

Ceci termine les paramètres de Jupyter Lab.

4.3. Paramètres du code VS

Ensuite, définissez les paramètres de développement à distance avec VS Code.

4.3.1. Préparation de la connexion avec ssh

Tout d'abord, si vous ne l'avez pas déjà fait, vous devez vous préparer à l'échange de clés afin de pouvoir vous connecter au serveur distant depuis votre PC local avec ssh. Je vais omettre la procédure détaillée, mais je pense que ici etc. sera utile.

4.3.2. Installation du pack d'extension de développement à distance

Suivez ces étapes (https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack) pour installer le pack d'extension de développement à distance dans Visual Studio.

4.3.3. Paramètres de connexion à un serveur distant à partir de VS Code

Suivez les étapes ci-dessous pour vous connecter à un serveur distant à partir de VS Code 1 et modifier les dossiers et fichiers. (À partir de la deuxième fois, vous pouvez également vous connecter à l'aide des paramètres enregistrés.)

  1. Cliquez sur le bouton en bas à gauche de l'écran
skitch.2.png 2. Lorsque la palette de commandes s'affiche, sélectionnez "Remote-SSH: Connect to Host". skitch.1.png 3. Sélectionnez "Ajouter un nouvel hôte SSH ..." skitch.png 4. Entrez la commande d'accès avec ssh à partir de la ligne de commande. Par exemple, entrez: Pratique!
ssh user@nom d'hôte-nom du port p
skitch.4.png 5. Spécifiez l'emplacement d'enregistrement des paramètres ssh (en général, spécifiez celui sous le dossier personnel) skitch.3.png 6. Cliquez sur le bouton "Connecter" dans la boîte de dialogue affichée en bas à droite skitch.5.png

4.3.4. Installation de l'extension Python pour Visual Studio Code

Ensuite, installez l'extension Python pour Visual Studio Code à partir de ici pour déboguer Python sur VS Code.

Ceci termine la connexion de VS Code au serveur distant. Cette procédure vous permet d'éditer des fichiers et des dossiers sur le serveur distant avec VS Code comme s'ils se trouvaient sur votre PC local.

5. Exécutez l'exemple de programme

5.1. Description de l'exemple de programme

C'est très simple, mais j'utiliserai l'exemple de programme ci-dessous. Tout d'abord, sur le serveur distant, enregistrez les fichiers suivants dans le même répertoire où vous avez enregistré le notebook.

sample.py


import numpy as np

def sample(x):
    y = np.square(x)
    return y

5.2. Accès à Jupyter Lab

Ensuite, démarrez JupyterLab sur le serveur distant et accédez à JupyterLab à partir du navigateur sur le PC local. (C'est la même chose que d'accéder normalement à Jupyter Lab.)

5.2.1. Démarrez Jupyter Lab sur un PC distant

jupyter lab --ip=0.0.0.0

5.2.2. Accéder à Jupyter Lab

Vous pouvez trouver le message suivant dans le journal lorsque jupyterLab est démarré, vous pouvez donc ouvrir JupyterLab en accédant à l'URL depuis votre PC local. * Au moment de l'accès, l'adresse IP sera remplacée par celle du PC distant.

    To access the notebook, open this file in a browser:
        file:///home/jupyter/.local/share/jupyter/runtime/nbserver-13-open.html
    Or copy and paste one of these URLs:
        http://(da9742c1f7ef or 127.0.0.1):8888/?token=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Vous pouvez accéder à JupyterLab en accédant à la sortie URL lorsque 5.2.1 JupyterLab démarre à partir d'un navigateur sur votre PC local.

5.3. Spécifier le noyau et créer un notebook

Lorsque vous accédez à JupyterLab, vous devriez voir un noyau appelé "Python3 debug" dans la colonne Notebook comme indiqué ci-dessous. (Il s'agit d'un noyau utilisant ptvsd défini à l'étape 4.2.2.) Cliquez sur ce bouton pour créer un nouveau bloc-notes. JupyterLab.png

Le coin supérieur droit de l'écran est "Python3 Debug", et vous pouvez voir que le noyau pour le débogage créé précédemment est utilisé.

JupyterLab2.png

Pour le moment, créez un notebook comme celui ci-dessous et exécutez-le.

Jupyter_and_VSCode_sample.png

5.4. Configuration du débogage à distance avec VS Code

5.4.1. Se connecter à un serveur distant et ouvrir un projet

Suivez les étapes de 4.3 pour vous connecter au serveur distant avec VS Code. Une fois connecté, ouvrez l'exemple de programme. C'est comme ça.

sample_py.png

5.4.2. Paramètres de débogage (paramètres launch.json)

Suivez les étapes ci-dessous pour configurer le débogage.

VSCode2.png

Les paramètres sont les suivants.

--port: spécifiez le port défini dans les paramètres du noyau de ptvsd. --host: spécifiez l'adresse IP du serveur distant. --pathMappings: localRoot doit être $ {workspaceFolder} comme indiqué dans l'exemple ci-dessous. remoteRoot spécifie le dossier sur le serveur distant où les fichiers sont stockés.

{
    //Vous pouvez utiliser IntelliSense pour apprendre les attributs disponibles.
    //Survolez et affichez la description des attributs existants.
    //Vérifiez les éléments suivants pour plus d'informations: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
    
        {
            "name": "Python:attacher",
            "type": "python",
            "request": "attach",
            "port": 19204,
            "host": "192.168.2.200",
            "pathMappings": [
                {
                    "localRoot": "${workspaceFolder}",
                    "remoteRoot": "/home/jupyter/proj/docker"
                }
            ]
        }
    ]
}

Ceci termine les paramètres de débogage. Ensuite, nous allons déboguer.

5.5. Attacher au processus JupyterLab et exécuter le débogage

La procédure de débogage est la suivante. Voir également la vidéo de démonstration au début pour plus de détails.

  1. Après avoir défini un point d'arrêt sur VS Code, le cas échéant, exécutez le jeu "Python attach" défini précédemment.

  2. Exécutez le notebook depuis JupyterLab

  3. Le traitement est interrompu au point d'arrêt, donc déboguez-le.

  4. Le résultat de la commande exécutée dans "Debug Console" sur VS Code est également affiché sur Jupyter Lab. Surtout, c'est très pratique car vous pouvez afficher des variables internes avec matplotlib etc. et les afficher sous forme de graphique!

  5. Résumé Jusqu'à présent, nous avons expliqué comment déboguer un processus Python exécuté à partir de JupyterLab en l'attachant à distance à partir de VS Code. C'est très pratique, alors essayez-le. C'est un peu griffonné, donc il peut y avoir des lacunes. Si vous avez des questions, veuillez commenter et j'aimerais ajouter ou corriger le cas échéant.

Recommended Posts

Procédure d'attachement et de débogage de VS Code vers Jupyter Lab sur un serveur distant
Exécuter le notebook Jupyter sur un serveur distant
Procédure de création d'un environnement virtuel Python avec VS Code sous Windows
[Jupyter Notebook / Lab] Trois méthodes de débogage sur Jupyter [Pdb]
Bon code et mauvais code à comparer avec la mini-carte
Construire un environnement Python sur un Mac, jusqu'au point d'utiliser Jupyter Lab
Un moyen simple de lancer Jupyter Notebook / Lab et de définir un mot de passe
Création d'un environnement de développement Python sur Windows - De l'installation d'Anaconda à la liaison d'Atom et de Jupyter Notebook -
Comment développer des conteneurs sur des serveurs distants avec VS Code Remote-Containers
Migrer de VS Code vers PyCharm
Comment créer un environnement d'exécution Python et Jupyter avec VSCode
Configurez un serveur de référentiel yum sur la série CentOS 7 et faites-y référence localement et à partir d'autres serveurs, etc.
J'ai créé un outil pour convertir Jupyter py en ipynb avec VS Code
Je veux formater et vérifier le code Python à mon goût sur VS Code
Construisez Linux sur un environnement Windows. Étapes pour installer Laradock et migrer
Let Code Day6 commençant à zéro "1342. Nombre d'étapes pour réduire un nombre à zéro"
Exécuter un script depuis Jupyter pour traiter
Démarrez le notebook jupyter sur le serveur GPU (serveur distant)
Construire un notebook jupyter sur un serveur distant (CentOS)
Étapes pour exécuter TensorFlow 2.1 à partir de Jupyter sur le front-end Spacon ITO (avec GPU)
Compilation croisée de Raspberry Pi et création d'un environnement de développement de débogage à distance avec VS Code
Lorsque je me suis connecté à un serveur Jupyter distant avec VScode, il était distant mais local.
Introduisez VS Code et le développement à distance dans un environnement hors ligne pour rendre le développement Linux confortable
Créez un environnement PYNQ sur Ultra96 V2 et connectez-vous à Jupyter Notebook
Envoyer un message de Slack à un serveur Python
Activer Jupyter Notebook avec conda sur un serveur distant
Comment Git GSR à partir de Jupyter Lab de GCP
De l'introduction de Flask sur CentOS au service sur Nginx et uWSGI
Étapes pour créer rapidement un environnement d'apprentissage en profondeur sur Mac avec TensorFlow et OpenCV
[Django] Créez rapidement un environnement de développement de conteneur Django (Docker) à l'aide de VS Code + Remote Containers
Comment créer un environnement d'exécution virtuelle pour Python à l'aide de Visual Studio Code et de pipenv sur une machine Windows (également le notebook Jupyter)
Étapes pour mesurer la couverture et obtenir des badges sur codecov.io
Étapes de l'installation de Python 3 à la création d'une application Django
Comment créer un package Python à l'aide de VS Code
Comment exécuter Django sur IIS sur un serveur Windows
Déboguer à distance l'environnement Django créé avec docker-compose avec VS Code
Je veux me débarrasser des avertissements d'importation de Pyright et pylint dans VSCode
J'ai créé un serveur avec socket Python et ssl et j'ai essayé d'y accéder depuis le navigateur