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.

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

2. Motivation
3. 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.
4. 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.
5. 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.

• Dans JupyterLab, vous pouvez utiliser n'importe quel processus (pas nécessairement Python) comme interpréteur en utilisant un mécanisme appelé noyau. Dans cet article, en combinant ce qui précède, l'explication ci-dessus est réalisée.

4. Construction de l'environnement

4.1. Construction d'un environnement de serveur distant

4.1.1. Prérequis

• Dans cet article, nous avons construit l'environnement basé sur l'image Docker "tensorflow / tensorflow: 1.14.0-gpu-py3-jupyter". Cependant, si vous avez déjà installé Jupyter Lab avec anaconda etc., vous pouvez l'utiliser tel quel. (Je vais l'expliquer ci-dessous, mais le fait est que cela fonctionne si ptvsd est installé sur le serveur distant et défini comme noyau de Jupyter Lab.)

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

• En particulier, vous avez besoin de jupyterlab et ptvsd.
• Cette fois, je vais installer numpy, matplotlib, scikit_learn.
• À partir d'avril 2020, la version 2 de jupyterlab est sortie, mais comme de nombreuses extensions ne sont pas encore prises en charge, nous installerons la 1.0.2 cette fois.

# 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.)

• Je pense que le propriétaire de ce répertoire est root, donc enregistrez-le en tant que root.

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

ssh user@nom d'hôte-nom du port p

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.

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é.

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

• Il semble que l'essentiel ne peut pas être collé sur Qiita, mais veuillez vous référer à ici pour la source.

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.

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

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

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.

• Si le paramètre de point d'arrêt ne fonctionne pas, il peut y avoir un problème avec le paramètre pathMappings, c'est donc une bonne idée de jouer avec.

{
    //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.