[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.
スクリーンショット 2020-04-08 00.09.27.png

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

  1. Motivation
  2. 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.
  3. Andererseits ist es bei der Überprüfung mit dem auf diese Weise entwickelten Programm häufig zweckmäßig, es von JupyterLab aus aufzurufen.
  4. 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

4. Umweltbau

4.1 Aufbau einer Remote-Serverumgebung

4.1.1. Voraussetzungen

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

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

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
skitch.2.png 2. Wenn die Befehlspalette angezeigt wird, wählen Sie "Remote-SSH: Verbindung zum Host herstellen". skitch.1.png 3. Wählen Sie "Neuen SSH-Host hinzufügen ...". skitch.png 4. Geben Sie den Befehl für den Zugriff mit ssh über die Befehlszeile ein. Geben Sie beispielsweise Folgendes ein: Praktisch!
ssh user@Hostname-p Portname
skitch.4.png 5. Geben Sie den Speicherort der SSH-Einstellungen an (normalerweise den unter dem persönlichen Ordner). skitch.3.png 6. Klicken Sie im Dialogfeld unten rechts auf die Schaltfläche "Verbinden" skitch.5.png

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. JupyterLab.png

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

JupyterLab2.png

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

Jupyter_and_VSCode_sample.png

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.

sample_py.png

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

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

VSCode2.png

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.

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

Recommended Posts

Verfahren zum Anhängen und Debuggen von VS-Code an Jupyter Lab auf einem Remote-Server
Führen Sie Jupyter Notebook auf einem Remote-Server aus
Vorgehensweise zum Erstellen einer virtuellen Python-Umgebung mit VS-Code unter Windows
[Jupyter Notebook / Lab] Drei Möglichkeiten zum Debuggen auf Jupyter [Pdb]
Guter und schlechter Code zum Vergleich mit Minikarten
Erstellen einer Python-Umgebung auf einem Mac bis zur Verwendung von Jupyter Lab
Eine einfache Möglichkeit, Jupyter Notebook / Lab zu starten und ein Kennwort festzulegen
Erstellen einer Python-Entwicklungsumgebung unter Windows - Von der Installation von Anaconda bis zur Verknüpfung von Atom und Jupyter Notebook -
So entwickeln Sie Container auf Remote-Servern mit VS Code Remote-Containern
Migrieren Sie von VS Code zu PyCharm
So erstellen Sie eine Python- und Jupyter-Ausführungsumgebung mit VSCode
Richten Sie einen yum-Repository-Server unter CentOS 7 ein und verweisen Sie lokal und von anderen Servern usw. darauf.
Ich habe ein Tool erstellt, um Jupyter py mit VS Code in ipynb zu konvertieren
Ich möchte Python-Code auf VS-Code nach meinen Wünschen formatieren und überprüfen
Erstellen Sie Linux in einer Windows-Umgebung. Schritte zum Installieren und Migrieren von Laradock
Lassen Sie Code Day6 ab Null beginnen "1342. Anzahl der Schritte, um eine Zahl auf Null zu reduzieren"
Führen Sie ein Skript von Jupyter aus, um es zu verarbeiten
Starten Sie das Jupiter-Notebook auf dem GPU-Server (Remote-Server).
Erstellen Sie ein Jupyter-Notebook auf einem Remote-Server (CentOS).
Schritte zum Ausführen von TensorFlow 2.1 von Jupyter auf dem Spacon ITO-Frontend (mit GPU)
Cross-Compilieren von Raspberry Pi und Erstellen einer Remote-Debug-Entwicklungsumgebung mit VS Code
Als ich mit VScode eine Verbindung zu einem entfernten Jupyter-Server herstellte, war dieser entfernt, aber lokal.
Führen Sie VS Code und Remote Development in die Offline-Umgebung ein, um die Linux-Entwicklung komfortabel zu gestalten
Erstellen Sie eine PYNQ-Umgebung auf Ultra96 V2 und melden Sie sich bei Jupyter Notebook an
Senden Sie eine Nachricht von Slack an einen Python-Server
Aktivieren Sie Jupyter Notebook mit conda auf dem Remote-Server
Wie man GSR von Jupyter Lab of GCP git
Von der Einführung von Flask unter CentOS bis zum Service unter Nginx und uWSGI
Schritte zum schnellen Erstellen einer umfassenden Lernumgebung auf einem Mac mit TensorFlow und OpenCV
[Django] Verwenden Sie VS Code + Remote-Container, um schnell eine Entwicklungsumgebung für Django-Container (Docker) zu erstellen.
So erstellen Sie eine virtuelle Ausführungsumgebung für Python mit Visual Studio Code und pipenv auf einem Windows-Computer (auch Jupyter-Notebook)
Schritte zum Messen der Abdeckung und zum Abrufen von Abzeichen auf codecov.io
Schritte von der Installation von Python 3 bis zur Erstellung einer Django-App
So erstellen Sie ein Python-Paket mit VS Code
So führen Sie Django unter IIS auf einem Windows-Server aus
Debuggen Sie die mit Docker-Compose mit VS-Code erstellte Django-Umgebung aus der Ferne
Ich möchte Importwarnungen von Pyright und pylint in VSCode entfernen
Ich habe einen Server mit Python-Socket und SSL erstellt und versucht, über den Browser darauf zuzugreifen