Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Tutorial: Richten Sie ein Jupyter-Notebook ein, um ETL-Skripte JupyterLab zu testen und zu debuggen In diesem Tutorial verbinden Sie ein Jupyter-Notebook, das auf Ihrem lokalen Computer JupyterLab ausgeführt wird, mit einem Entwicklungsendpunkt. So können Sie AWS Glue-ETL-Skripts (Extract, Transform and Load) interaktiv ausführen, debuggen und testen. In diesem Tutorial wird die Secure-Shell-Portweiterleitung (SSH) verwendet, um Ihren lokalen Computer mit einem AWS Glue-Entwicklungsendpunkt zu verbinden. Weitere Informationen finden Sie unter [Portweiterleitung](https://en.wikipedia.org/wiki/Port_forwarding) bei Wikipedia. ## Schritt 1: Installation und Sparkmagic JupyterLab Sie können die Installation mit JupyterLab `conda` oder durchführen. `pip` `conda`ist ein Open-Source-Paketverwaltungssystem und ein Umgebungsverwaltungssystem, das unter Windows, MacOS und Linux läuft. `pip`ist der Paket-Installer für Python. Unter macOS muss Xcode installiert sein, bevor Sie SparkMagic installieren können. 1. Install JupyterLab, Sparkmagic und die zugehörigen Erweiterungen. ``` $ conda install -c conda-forge jupyterlab $ pip install sparkmagic $ jupyter nbextension enable --py --sys-prefix widgetsnbextension $ jupyter labextension install @jupyter-widgets/jupyterlab-manager ``` 1. Überprüfen Sie das `sparkmagic`-Verzeichnis am `Location`. ``` $ pip show sparkmagic | grep Location Location: /Users/{{username}}/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages ``` 1. Ändern Sie Ihr Verzeichnis in das Verzeichnis`Location`, für das zurückgegeben wurde, und installieren Sie die Kernel für Scala und. PySpark ``` $ cd /Users/{{username}}/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages $ jupyter-kernelspec install sparkmagic/kernels/sparkkernel $ jupyter-kernelspec install sparkmagic/kernels/pysparkkernel ``` 1. Laden Sie eine einzelne `config`-Beispieldatei herunter. ``` $ curl -o ~/.sparkmagic/config.json https://raw.githubusercontent.com/jupyter-incubator/sparkmagic/master/sparkmagic/example_config.json ``` In dieser Konfigurationsdatei können Sie Spark-bezogene Parameter wie `driverMemory` und `executorCores` festlegen. ## Schritt 2: Starten JupyterLab Wenn Sie starten JupyterLab, wird Ihr Standard-Webbrowser automatisch geöffnet und die URL `http://localhost:8888/lab/workspaces/{workspace_name}` wird angezeigt. ``` $ jupyter lab ``` ## Schritt 3: Initiieren der SSH-Portweiterleitung zur Verbindung mit Ihrem Entwicklungsendpunkt Anschließend verwenden Sie die lokale SSH-Portweiterleitung, um einen lokalen Port (in diesem Fall `8998`) an das Remote-Ziel weiterzuleiten, das durch AWS Glue (`169.254.76.1:8998`) definiert wird. 1. Öffnen Sie ein separates Terminalfenster, das Ihnen Zugriff auf SSH gibt. Unter Microsoft Windows können Sie die von [Git for Windows](https://git-scm.com/downloads) bereitgestellte BASH-Shell verwenden oder [Cygwin](https://www.cygwin.com/) installieren. 1. Führen Sie den folgenden SSH-Befehl aus, folgendermaßen abgeändert: + Ersetzen Sie `{{private-key-file-path}}` durch einen Pfad zu der `.pem`-Datei, die den privaten Schlüssel enthält, der dem öffentlichen Schlüssel entspricht, die Sie verwendet haben, um Ihren Entwicklungsendpunkt zu erstellen. + Wenn Sie einen anderen Port als `8998` weiterleiten, ersetzen Sie `8998` durch die Portnummer, die Sie tatsächlich lokal verwenden. Die Adresse `169.254.76.1:8998` ist der Remote-Port und wird von Ihnen nicht geändert. + Ersetzen Sie `{{dev-endpoint-public-dns}}` durch die öffentliche DNS-Adresse Ihres Entwicklungsendpunkts. Um diese Adresse zu finden, navigieren Sie zu Ihrem Entwicklungsendpunkt in der AWS Glue-Konsole, wählen den Namen aus und kopieren die öffentliche Adresse unter **Public address**, die auf der Seite **Endpoint details (Endpunktdetails)** aufgelistet ist. ``` ssh -i {{private-key-file-path}} -NTL {{8998}}:169.254.76.1:8998 glue@{{dev-endpoint-public-dns}} ``` Es wird wahrscheinlich eine Warnmeldung angezeigt, die wie folgt aussieht: ``` The authenticity of host 'ec2-xx-xxx-xxx-xx.us-west-2.compute.amazonaws.com (xx.xxx.xxx.xx)' can't be established. ECDSA key fingerprint is SHA256:4e97875Brt+1wKzRko+JflSnp21X7aTP3BcFnHYLEts. Are you sure you want to continue connecting (yes/no)? ``` Geben Sie das Terminalfenster ein **yes** und lassen Sie es geöffnet, während Sie es verwenden JupyterLab. 1. Überprüfen Sie, ob die SSH-Portweiterleitung mit dem Entwicklungsendpunkt korrekt funktioniert. ``` $ curl localhost:8998/sessions {"from":0,"total":0,"sessions":[]} ``` ## Schritt 4: Ausführen eines einfachen Skriptfragments in einem Abschnitt des Notebooks Jetzt JupyterLab sollte Ihr Notizbuch mit Ihrem Entwicklungsendpunkt funktionieren. Geben Sie das folgende Skriptfragment in Ihr Notebook ein und führen Sie es aus. 1. Überprüfen Sie, ob Spark erfolgreich ausgeführt wird. Der folgende Befehl weist Spark an, `1` zu berechnen und anschließend den Wert zu drucken. ``` spark.sql("select 1").show() ``` 1. Prüfen Sie, ob die AWS Glue Data Catalog Integration funktioniert. Im folgenden Befehl werden die Tabellen im Data Catalog aufgelistet. ``` spark.sql("show tables").show() ``` 1. Überprüfen Sie, ob ein einfaches Skriptfragment, das AWS Glue-Bibliotheken verwendet, funktioniert. Das folgende Skript verwendet die `persons_json`-Tabellenmetadaten im AWS Glue Data Catalog , um einen `DynamicFrame` aus Ihren Beispieldaten zu erstellen. Es druckt dann die Elementzahlen und das Schema dieser Daten aus. ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext # Create a Glue context glueContext = GlueContext(SparkContext.getOrCreate()) # Create a DynamicFrame using the 'persons_json' table persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json") # Print out information about *this* data print("Count: ", persons_DyF.count()) persons_DyF.printSchema() ``` Die Ausgabe des Skripts sieht folgendermaßen aus. ``` Count: 1961 root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string ``` ## Fehlerbehebung + Wenn sich Ihr Computer während der Installation von JupyterLab hinter einem Unternehmens-Proxy oder einer Firewall befindet, können HTTP- und SSL-Fehler auftreten, die auf benutzerdefinierte Sicherheitsprofile zurückzuführen sind, die von den IT-Abteilungen des Unternehmens verwaltet werden. Im Folgenden finden Sie ein Beispiel für einen häufig auftretenden Fehler, wenn `conda` keine Verbindung zu den eigenen Repositorys herstellen kann: ``` CondaHTTPError: HTTP 000 CONNECTION FAILED for url ``` Dies kann passieren, weil Ihr Unternehmen Verbindungen zu weit verbreiteten Repositorys in Python und JavaScript Communities blockieren kann. Weitere Informationen finden Sie auf der JupyterLab Website unter [Installationsprobleme](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html#installation-problems). + Wenn bei der Verbindung mit Ihrem Entwicklungsendpunkt der Fehler *connection refused (Verbindung abgelehnt)* auftritt, ist Ihr Entwicklungsendpunkt möglicherweise nicht mehr auf dem neuesten Stand. Versuchen Sie, einen neuen Entwicklungsendpunkt zu erstellen und erneut eine Verbindung herzustellen.