[PYTHON] Verfahren zum Anhängen und Debuggen von VS-Code an Jupyter Lab auf einem Remote-Server

1. Was ist in diesem Beitrag zu erklären

Führen Sie die folgenden Schritte aus, um eine Umgebung zum Debuggen mit Jupyter Lab und VS Code zu erstellen.

1. Starten Sie Jupyter Lab auf einem Remote-Server
2. Rufen Sie eine Python-Klasse aus JupyterLab auf.
3. Schließen Sie zum Debuggen von VSCode aus eine Remote-Verbindung an das oben genannte JupyterLab-Notebook an.
4. Die Figur ist wie folgt.

Wenn Sie sich das folgende Video ansehen, können Sie sich ein Bild davon machen, was Sie tun können.

2. Motivation
3. JupyterLab ist praktisch, um einen kleinen Code zu schreiben und die Ergebnisse ordentlich miteinander zu teilen. Wenn Sie jedoch ernsthaft ein Programm erstellen, verwenden Sie wahrscheinlich einen Editor wie VSCode.
4. Andererseits ist es bei der Überprüfung mit dem auf diese Weise entwickelten Programm häufig zweckmäßig, es von JupyterLab aus aufzurufen.
5. In dieser Verwendung wird erläutert, wie Sie einen Haltepunkt für das von JupyterLab aufgerufene Programm festlegen und eine Umgebung zum Debuggen von VS Code erstellen.

3. Punkte der Umgebung, die dieses Mal erstellt werden sollen

• In VS Code ist es mithilfe eines Mechanismus namens Remote-Entwicklung möglich, Ordner und Dateien auf dem Remote-Server fast genauso zu bearbeiten wie auf dem lokalen PC, indem eine Verbindung mit ssh hergestellt wird. Einzelheiten finden Sie hier. Mit --VS Code können Sie Python-Prozesse auf dem Remote-Server anhängen und debuggen, indem Sie ein Paket namens ptvsd auf dem Remote-Server installieren. Einzelheiten finden Sie hier.
• In JupyterLab ist es möglich, einen beliebigen Prozess (nicht unbedingt Python) als Interpreter zu verwenden, indem ein Mechanismus namens Kernel verwendet wird. ――In diesem Artikel wird durch Kombinieren des Obigen die obige Erklärung realisiert.

4. Umweltbau

4.1 Aufbau einer Remote-Serverumgebung

4.1.1. Voraussetzungen

• In diesem Artikel haben wir die Umgebung basierend auf dem Docker-Image "Tensorflow / Tensorflow: 1.14.0-gpu-py3-jupyter" erstellt. ――Wenn Sie Jupyter Lab jedoch bereits mit Anaconda usw. installiert haben, können Sie es so verwenden, wie es ist. (Ich werde es unten erklären, aber der Punkt ist, dass es funktioniert, wenn ptvsd auf dem Remote-Server installiert und als Kernel von Jupyter Lab festgelegt ist.)

4.1.2 Installation der erforderlichen Apps

# 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. Nodejs installieren

Erforderlich, um die JupyterLab-Erweiterung zu installieren. Dieser Schritt ist nicht erforderlich, wenn Sie nur den Kernel konfigurieren möchten. Es ist jedoch besser, ihn für die bequeme Verwendung von Jupyter Lab zu unterstützen.

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

4.1.4 Python & Jupyter Lab installieren

• Insbesondere benötigen Sie jupyterlab und ptvsd.
• Dieses Mal werde ich numpy, matplotlib, scikit_learn installieren.
• Ab April 2020 ist Version 2 von jupyterlab verfügbar. Da jedoch viele Erweiterungen noch nicht unterstützt werden, werden wir diesmal 1.0.2 installieren.

# 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 Starten Sie ssh, um über VS-Code auf der lokalen PC-Seite darauf zuzugreifen

Erforderlich, um eine Verbindung zu einem Remote-Server von VS Code für die Remote-Entwicklung herzustellen. Öffnen Sie diesmal den SSH-Port auf 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

Starten Sie als nächstes ssh.

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

4.2 Jupyter Lab-Einstellungen

Richten Sie als Nächstes Jupyter Lab ein. Dieses Mal starten wir den jupyterLab-Server als jupyter-Benutzer.

4.2.1 Ändern Sie den Besitz des Verzeichnisses / usr / local / share / jupyter / lab

Ändern Sie zur Vorbereitung zunächst den Besitz des Verzeichnisses / usr / local / share / jupyter / lab in jupyter. Wenn Sie dies nicht tun, können Sie beim Start als Jupyter-Benutzer keine Erweiterungen aus JupyterLab installieren, was unpraktisch ist. Ich denke, es gibt einen besseren Weg (zum Beispiel, diese Dateien in Ihrem Home-Verzeichnis zu behalten). Hier werde ich den Besitz unten leicht ändern.

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

4.2.2 Legen Sie ptvsd als Kernel von Jupyter Lab fest

Speichern Sie zunächst die folgende Datei unter dem Dateinamen /usr/local/share/jupyter/kernels/ptvsd/kernel.json, damit Sie den Interpreter zum Debuggen aus JupyterLab aufrufen können. (Die Methode zum Aufrufen des hier festgelegten Interpreters aus JupyterLab wird später erläutert.)

• Ich denke, dass der Besitzer dieses Verzeichnisses root ist, also speichere es als 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"
}

Es ist so.

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

Damit sind die Jupyter Lab-Einstellungen abgeschlossen.

4.3 VS-Codeeinstellungen

Nehmen Sie als Nächstes Einstellungen für die Remoteentwicklung mit VS Code vor.

4.3.1 Vorbereitung der Verbindung mit ssh

Wenn Sie dies noch nicht getan haben, müssen Sie sich zunächst auf den Schlüsselaustausch vorbereiten, damit Sie mit ssh von Ihrem lokalen PC aus eine Verbindung zum Remote-Server herstellen können. Ich werde das detaillierte Verfahren weglassen, aber ich denke, dass hier usw. hilfreich sein wird.

4.3.2. Installieren des Remote Development Extension Pack

Führen Sie die folgenden Schritte aus (https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack), um das Remote Development-Erweiterungspaket in Visual Studio zu installieren.

4.3.3. Einstellungen zum Herstellen einer Verbindung zu einem Remote-Server über VS Code

Führen Sie die folgenden Schritte aus, um über VS Code 1 eine Verbindung zu einem Remote-Server herzustellen und Ordner und Dateien zu bearbeiten. (Ab dem zweiten Mal können Sie auch über die gespeicherten Einstellungen eine Verbindung herstellen.)

1. Klicken Sie auf die Schaltfläche unten links auf dem Bildschirm

ssh user@Hostname-p Portname

4.3.4 Installieren der Python-Erweiterung für Visual Studio Code

Installieren Sie als Nächstes die Python-Erweiterung für Visual Studio Code von hier, um Python in VS Code zu debuggen.

Damit ist die Verbindung von VS Code zum Remote-Server abgeschlossen. Mit diesem Verfahren können Sie Dateien und Ordner auf dem Remote-Server mit VS-Code so bearbeiten, als wären sie auf Ihrem lokalen PC.

5. Führen Sie das Beispielprogramm aus

5.1. Beschreibung des Beispielprogramms

Es ist sehr einfach, aber ich werde das folgende Beispielprogramm verwenden. Speichern Sie zunächst auf dem Remote-Server die folgenden Dateien in demselben Verzeichnis, in dem Sie das Notebook speichern.

sample.py

import numpy as np

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

5.2. Zugang zum Jupyter Lab

Starten Sie als Nächstes JupyterLab auf dem Remote-Server und greifen Sie über den Browser auf dem lokalen PC auf JupyterLab zu. (Dies entspricht dem normalen Zugriff auf Jupyter Lab.)

5.2.1 Starten Sie Jupyter Lab auf einem Remote-PC

jupyter lab --ip=0.0.0.0

5.2.2. Zugriff auf Jupyter Lab

Sie finden die folgende Meldung im Protokoll, wenn jupyterLab gestartet wird, sodass Sie JupyterLab öffnen können, indem Sie von Ihrem lokalen PC aus auf die URL zugreifen. * Zum Zeitpunkt des Zugriffs wird die IP-Adresse in die des Remote-PCs geändert.

    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

Sie können auf JupyterLab zugreifen, indem Sie auf die URL-Ausgabe zugreifen, wenn 5.2.1 JupyterLab über einen Browser auf Ihrem lokalen PC gestartet wird.

5.3 Geben Sie den Kernel an und erstellen Sie ein Notizbuch

Wenn Sie auf JupyterLab zugreifen, sollte in der Notebook-Spalte ein Kernel namens "Python3-Debug" angezeigt werden (siehe Abbildung unten). (Dies ist ein Kernel mit ptvsd, der in Schritt 4.2.2 festgelegt wurde.) Klicken Sie auf diese Schaltfläche, um ein neues Notizbuch zu erstellen.

Oben rechts auf dem Bildschirm befindet sich "Python3 Debug", und Sie können sehen, dass der zuvor erstellte Kernel für Debug verwendet wird.

Erstellen Sie vorerst ein Notizbuch wie das folgende und führen Sie es aus.

• Es scheint, dass das Wesentliche nicht in Qiita eingefügt werden kann, aber die Quelle finden Sie unter hier.

5.4. Remote-Debugging mit VS-Code einrichten

5.4.1 Stellen Sie eine Verbindung zu einem Remote-Server her und öffnen Sie ein Projekt

Befolgen Sie die Schritte in 4.3, um mit VS Code eine Verbindung zum Remote-Server herzustellen. Öffnen Sie nach dem Anschließen das Beispielprogramm. Es ist so.

5.4.2. Debug-Einstellungen (launch.json-Einstellungen)

Führen Sie die folgenden Schritte aus, um das Debuggen einzurichten.

Die Einstellungen sind wie folgt.

--port: Geben Sie den in den Kerneleinstellungen von ptvsd festgelegten Port an. --host: Geben Sie die IP-Adresse des Remote-Servers an. --pathMappings: localRoot sollte $ {workspaceFolder} sein, wie im folgenden Beispiel gezeigt. remoteRoot gibt den Ordner auf dem Remote-Server an, in dem die Dateien gespeichert sind.

• Wenn die Haltepunkteinstellung nicht funktioniert, liegt möglicherweise ein Problem mit der Einstellung pathMappings vor. Es ist daher eine gute Idee, damit herumzuspielen.

{
    //Mit IntelliSense können Sie die verfügbaren Attribute kennenlernen.
    //Bewegen Sie den Mauszeiger und zeigen Sie die Beschreibung der vorhandenen Attribute an.
    //Überprüfen Sie das Folgende für weitere Informationen: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
    
        {
            "name": "Python:anfügen",
            "type": "python",
            "request": "attach",
            "port": 19204,
            "host": "192.168.2.200",
            "pathMappings": [
                {
                    "localRoot": "${workspaceFolder}",
                    "remoteRoot": "/home/jupyter/proj/docker"
                }
            ]
        }
    ]
}

Damit sind die Debug-Einstellungen abgeschlossen. Als nächstes debuggen wir tatsächlich.

5.5. An JupyterLab-Prozess anhängen und Debug ausführen

Das Debugging-Verfahren ist wie folgt. Siehe auch das Demo-Video am Anfang für Details.

1. Nachdem Sie einen Haltepunkt für VS-Code festgelegt haben, führen Sie den zuvor festgelegten Satz "Python-Anhang" aus.

2. Führen Sie das Notebook über JupyterLab aus

3. Die Verarbeitung wird am Haltepunkt unterbrochen, also debuggen Sie sie.

4. Das Ergebnis des Befehls, der in "Debug Console" für VS Code ausgeführt wird, wird auch in JupyterLab angezeigt. Dies ist besonders praktisch, da Sie interne Variablen mit matplotlib usw. anzeigen und als Grafik anzeigen können!

5. Zusammenfassung Bisher haben wir erklärt, wie ein von JupyterLab ausgeführter Python-Prozess durch Remote-Anhängen von VS Code debuggt wird. Es ist sehr praktisch, also versuchen Sie es bitte. Es ist ein wenig gekritzelt, daher kann es einige Mängel geben. Wenn Sie Fragen haben, kommentieren Sie diese bitte und ich möchte sie gegebenenfalls hinzufügen oder korrigieren.