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.
# Entwicklungsendpunkte
**Anmerkung**
**Die Konsolenerfahrung für Entwicklerendpunkte wurde ab dem 31. März 2023 entfernt.** Das Erstellen, Aktualisieren und Überwachen von Entwicklungsendpunkten ist weiterhin über [API für Entwicklungsendpunkte](aws-glue-api-dev-endpoint.md) und [ AWS Glue-CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/index.html#cli-aws-glue) möglich.
Aus den unten aufgeführten Gründen empfehlen wir dringend, von Entwicklungsendpunkten zu interaktiven Sitzungen zu migrieren. Erforderliche Maßnahmen zum Migrieren von Entwicklungsendpunkten zu interaktiven Sitzungen finden Sie unter [Migrieren von Entwicklungsendpunkten zu interaktiven Sitzungen](https://docs.aws.amazon.com/glue/latest/dg/development-migration-checklist.html).
| Description | Entwicklungsendpunkte | Interaktive Sitzungen |
| --- | --- | --- |
| Unterstützung der Glue-Version | Unterstützt die AWS Glue-Versionen 0.9 und 1.0 | Unterstützt AWS Glue-Version 2.0 und höher |
| Entwicklungsendpunkte sind in Zukunft nicht mehr in Asien-Pazifik (Jakarta) (ap-southeast-3), im Nahen Osten (VAE) (me-central-1), in Europa (Spanien) (eu-south-2), in Europa (Zürich) (eu-central-2) oder in anderen neuen Regionen verfügbar | Interaktive Sitzungen und Notebooks sind in der Region Naher Osten (VAE) (me-central-1) derzeit nicht verfügbar, können aber zu einem späteren Zeitpunkt verfügbar gemacht werden |
| Zugriffsmethode auf den Spark-Cluster | Unterstützt SSH, REPL-Shell, Jupyter-Notebook, IDE (z. B.) PyCharm | unterstützt AWS Glue Studio Notebooks, Jupyter-Notebooks, diverse Notebooks IDEs (z. B. Visual Studio Code) und KI-Notebooks PyCharm SageMaker |
| Zeit bis zur ersten Abfrage | Erfordert 10–15 Minuten zum Einrichten eines Spark-Clusters | Das Einrichten eines kurzlebigen Spark-Clusters kann bis zu 1 Minute dauern |
| Preismodell | AWS Gebühren für Entwicklungsendpunkte basieren auf der Zeit, zu der der Endpunkt bereitgestellt wird, und der Anzahl der. DPUs Bei den Entwicklungsendpunkten gibt es kein Timeout. Für jeden bereitgestellten Entwicklungsendpunkt gibt es eine Mindestabrechnungsdauer von 10 Minuten. Darüber hinaus AWS fallen Gebühren für Jupyter-Notebooks auf EC2 Amazon-Instances und SageMaker KI-Notebooks an, wenn Sie sie mit Entwicklungsendpunkten konfigurieren. | AWS Gebühren für interaktive Sitzungen basieren auf der Zeit, in der die Sitzung aktiv ist, und der Anzahl der DPUs. Interaktive Sitzungen haben konfigurierbare Leerlauf-Timeouts. AWS Glue StudioNotebooks bieten eine integrierte Oberfläche für interaktive Sitzungen und werden ohne zusätzliche Kosten angeboten. Für jede interaktive Sitzung gilt eine Mindestabrechnungsdauer von 1 Minute. AWS Glue Studio-Notebooks bieten eine integrierte Schnittstelle für interaktive Sitzungen und werden ohne zusätzliche Kosten angeboten |
| Konsolenerfahrung | Nur über die CLI und API verfügbar | Verfügbar über die AWS Glue Konsole, CLI und APIs |
# Migrieren von Entwicklungsendpunkten zu interaktiven Sitzungen
Verwenden Sie die folgende Checkliste, um die geeignete Methode zum Migrieren von Entwicklungsendpunkten zu interaktiven Sitzungen zu bestimmen.
**Hängt Ihr Skript von AWS Glue 0.9- oder 1.0-spezifischen Features ab (z. B. HDFS, YARN usw.)?**
Wenn die Antwort ja lautet, erfahren Sie unter [Migrieren von AWS Glue-Aufträgen zu AWS Glue-Version 3.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html) eine Anleitung, wie Sie von Glue 0.9 oder 1.0 zu Glue 3.0 und höher migrieren können.
**Welche Methode verwenden Sie für den Zugriff auf Ihren Entwicklerendpunkt?**
| Wenn Sie diese Methode verwenden | Dann tun Sie das |
| --- | --- |
| SageMaker KI-Notizbuch, Jupyter-Notizbuch oder JupyterLab | Migrieren Sie zu [AWS Glue Studio-Notebook](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-gs-notebook.html), indem Sie .ipynb-Dateien auf Jupyter herunterladen, und erstellen Sie einen neuen AWS Glue Studio-Notebook-Auftrag, indem Sie die .ipynb-Datei hochladen. Alternativ können Sie auch [ SageMaker AI Studio](https://aws.amazon.com/blogs/machine-learning/prepare-data-at-scale-in-amazon-sagemaker-studio-using-serverless-aws-glue-interactive-sessions/) verwenden und den Kernel auswählen. AWS Glue |
| Zeppelin Notebook | Konvertieren Sie das Notebook manuell in ein Jupyter Notebook, indem Sie Code kopieren und einfügen, oder automatisch mit einem Konverter eines Drittanbieters wie ze2nb. Verwenden Sie dann das Notizbuch in AWS Glue Studio Notebook oder SageMaker AI Studio. |
| IDE | Siehe [AWS GlueAutorenjobs mit PyCharm AWS Glue interaktiven Sitzungen](https://aws.amazon.com/blogs/big-data/author-aws-glue-jobs-with-pycharm-using-aws-glue-interactive-sessions/) oder [Verwenden interaktiver Sitzungen mit Microsoft Visual Studio Code](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-vscode.html). |
| REPL | installieren Sie das [https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html) lokal und führen Sie anschließend den folgenden Befehl aus: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/development-migration-checklist.html) |
| SSH | Hier gibt es keine entsprechende Option für interaktive Sitzungen. Alternativ können Sie ein Docker-Image verwenden. Weitere Informationen finden Sie unter [Entwickeln mit einem Docker-Image](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-libraries.html#develop-local-docker-image). |
In den folgenden Abschnitten erhalten Sie Informationen zur Verwendung von Entwicklungsendpunkten, um Aufträge in AWS Glue Version 1.0 zu entwickeln.
**Topics**
+ [Migrieren von Entwicklungsendpunkten zu interaktiven Sitzungen](development-migration-checklist.md)
+ [Entwickeln von Skripts unter Verwendung von Entwicklungsendpunkten](dev-endpoint.md)
+ [Verwalten von Notebooks](notebooks-with-glue.md)
# Entwickeln von Skripts unter Verwendung von Entwicklungsendpunkten
**Anmerkung**
Entwicklungsendpunkte werden nur für Versionen AWS Glue vor 2.0 unterstützt. Für eine interaktive Umgebung, in der Sie ETL-Skripts erstellen und testen können, verwenden Sie [Notebooks on AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html).
AWS Glue kann eine Umgebung erstellen, die als *Entwicklungsendpunkt*bezeichnet wird und die Sie verwenden können, um Ihre Skripts zum Extrahieren, Transformieren und Laden (Extract, Transform, Load, ETL) iterativ zu entwickeln und zu testen. Sie können Entwicklungsendpunkte über die AWS Glue-Konsole oder -API erstellen, bearbeiten und löschen.
## Verwalten Ihrer lokalen Entwicklungsumgebung
Wenn Sie einen Entwicklungsendpunkt erstellen, geben Sie Konfigurationswerte an, um die Entwicklungsumgebung bereitzustellen. Diese Werte teilen AWS Glue mit, wie das Netzwerk eingerichtet werden muss, sodass Sie sicher auf den Entwicklungsendpunkt zugreifen können und der Endpunkt Zugriff auf Ihre Datenspeicher hat.
Anschließend erstellen Sie ein Notebook, das eine Verbindung mit dem Entwicklungsendpunkt herstellt, und verwenden das Notebook zum Schreiben und Testen Ihres ETL-Skripts. Wenn Sie mit den Ergebnissen Ihres Entwicklungsprozesses zufrieden sind, können Sie einen ETL-Auftrag zum Ausführen des Skripts erstellen. Mit diesem Prozess können Sie Funktionen hinzufügen und Ihr Skript interaktive debuggen.
In den Tutorials in diesem Abschnitt erfahren Sie, wie Sie Entwicklungsendpunkte mit Notizbüchern verwenden.
**Topics**
+ [Verwalten Ihrer lokalen Entwicklungsumgebung](#dev-endpoint-managing-dev-environment)
+ [Workflow für Entwicklungsendpunkte](dev-endpoint-workflow.md)
+ [So funktionieren AWS Glue Entwicklungsendpunkte mit Notebooks SageMaker](dev-endpoint-how-it-works.md)
+ [Hinzufügen eines Entwicklungsendpunkts](add-dev-endpoint.md)
+ [Zugreifen auf den Entwicklungsendpunkt](dev-endpoint-elastic-ip.md)
+ [Tutorial: Richten Sie ein Jupyter-Notebook ein, um ETL-Skripte JupyterLab zu testen und zu debuggen](dev-endpoint-tutorial-local-jupyter.md)
+ [Tutorial: Verwenden Sie ein SageMaker KI-Notizbuch mit Ihrem Entwicklungsendpunkt](dev-endpoint-tutorial-sage.md)
+ [Tutorial: Verwenden Sie eine REPL Shell mit Ihrem Entwicklungsendpunkt](dev-endpoint-tutorial-repl.md)
+ [Tutorial: PyCharm Professional mit einem Entwicklungsendpunkt einrichten](dev-endpoint-tutorial-pycharm.md)
+ [Erweiterte Konfiguration: Freigeben von Entwicklungsendpunkten unter mehreren Benutzern](dev-endpoint-sharing.md)
# Workflow für Entwicklungsendpunkte
Um einen AWS Glue-Entwicklungsendpunkt zu verwenden, können Sie diesem Workflow folgen:
1. Erstellen Sie mithilfe der API einen Entwicklungsendpunkt. Dieser Endpunkt wird in einer Virtual Private Cloud (VPC) mit den von Ihnen definierten Sicherheitsgruppen gestartet.
1. Die API fragt den Entwicklungsendpunkt ab, bis dieser bereitgestellt und einsatzbereit ist. Wenn er verwendet werden kann, stellen Sie mithilfe einer der folgenden Methoden eine Verbindung mit dem Entwicklungsendpunkt her, um AWS Glue-Skripts zu erstellen und zu testen.
+ Erstellen Sie ein SageMaker KI-Notizbuch in Ihrem Konto. Weitere Informationen zum Erstellen eines Notebooks finden Sie unter [Code mit AWS Glue Studio-Notebooks erstellen](notebooks-chapter.md).
+ Öffnen Sie ein Terminalfenster, um eine direkte Verbindung zu einem Entwicklungsendpunkt herzustellen.
+ Wenn Sie die Professional Edition der JetBrains [PyCharm Python-IDE](https://www.jetbrains.com/pycharm/) haben, verbinden Sie sie mit einem Entwicklungsendpunkt und verwenden Sie sie für die interaktive Entwicklung. Wenn Sie `pydevd` Anweisungen in Ihr Skript einfügen, PyCharm kann Remote-Breakpoints unterstützt werden.
1. Wenn Sie mit dem Debuggen und Testen auf Ihrem Entwicklungsendpunkt fertig sind, können Sie ihn löschen.
# So funktionieren AWS Glue Entwicklungsendpunkte mit Notebooks SageMaker
Eine der häufigsten Methoden für den Zugriff auf Ihre Entwicklungsendpunkte ist die Verwendung von [Jupyter](https://jupyter.org/) auf Notebooks. SageMaker Das Jupyter Notebook ist eine Open-Source-Webanwendung, die häufig für die Visualisierung, die Analytik, Machine Learning und in ähnlichen Anwendungsfällen genutzt wird. Ein AWS Glue SageMaker Notizbuch bietet Ihnen ein Jupyter-Notebook-Erlebnis mit Entwicklungsendpunkten. AWS Glue Im AWS Glue SageMaker Notebook ist die Jupyter-Notebook-Umgebung mit einem Open-Source-Jupyter-Plugin vorkonfiguriert [SparkMagic](https://github.com/jupyter-incubator/sparkmagic), mit dem Spark-Jobs an einen Remote-Spark-Cluster gesendet werden können. [Apache Livy](https://livy.apache.org) ist ein Service, der die Interaktion mit einem Remote-Spark-Cluster über eine REST-API ermöglicht. Im AWS Glue SageMaker Notizbuch SparkMagic ist es so konfiguriert, dass es die REST-API für einen Livy-Server aufruft, der auf einem Entwicklungsendpunkt läuft. AWS Glue
Im folgenden Textfluss wird die Funktionsweise der einzelnen Komponenten erläutert:
*AWS Glue SageMaker notebook: (Jupyter → SparkMagic) → (Netzwerk) → AWS Glue Entwicklungsendpunkt: (Apache Livy → Apache Spark)*
Sobald Sie Ihr Spark-Skript, das in jedem Absatz geschrieben wurde, auf einem Jupyter-Notebook ausgeführt haben, wird der Spark-Code über an den Livy-Server übermittelt. Anschließend wird ein Spark-Job mit dem Namen „ SparkMagicLivy-Session-N“ auf dem Spark-Cluster ausgeführt. Dieser Auftrag wird als Livy-Sitzung bezeichnet. Der Spark-Auftrag wird ausgeführt, während die Notebook-Sitzung aktiv ist. Der Spark-Auftrag wird beendet, wenn Sie den Jupyter-Kernel im Notebook herunterfahren oder die Sitzung abgelaufen ist. Pro Notebook-Datei (mit der Endung .ipynb) wird ein Spark-Auftrag gestartet.
Sie können einen einzigen Entwicklungsendpunkt mit mehreren Notebook-Instanzen verwenden. AWS Glue SageMaker Sie können in jeder Notebook-Instanz mehrere SageMaker Notebook-Dateien erstellen. Wenn Sie jede Notebook-Datei öffnen und die Absätze ausführen, wird eine Livy-Sitzung pro Notebook-Datei auf dem Spark-Cluster über SparkMagic gestartet. Jede Livy-Sitzung entspricht einem einzelnen Spark-Auftrag.
## Standardverhalten für AWS Glue Entwicklungsendpunkte und Notebooks SageMaker
Die Spark-Aufträge werden auf der Grundlage der [Spark-Konfiguration](https://spark.apache.org/docs/2.4.3/configuration.html) ausgeführt. Es gibt mehrere Möglichkeiten, die Spark-Konfiguration festzulegen (z. B. die Spark-Cluster-Konfiguration, SparkMagic die Konfiguration usw.).
Standardmäßig weist Spark einer Livy-Sitzung Clusterressourcen auf der Grundlage der Spark-Clusterkonfiguration zu. In den AWS Glue-Entwicklungsendpunkten hängt die Clusterkonfiguration vom Worker-Typ ab. In dieser Tabelle werden die gängigen Konfigurationen pro Worker-Typ erläutert.
****
| | Standard | G.1X | G.2X |
| --- | --- | --- | --- |
| spark.driver.memory | 5G | 10G | 20G |
| spark.executor.memory | 5G | 10G | 20G |
| spark.executor.cores | 4 | 8 | 16 |
| spark.dynamicAllocation.enabled | TRUE | TRUE | TRUE |
Die maximale Anzahl von Spark-Executors wird automatisch anhand einer Kombination aus DPU (oder `NumberOfWorkers`) und Worker-Typ berechnet.
****
| | Standard | G.1X | G.2X |
| --- | --- | --- | --- |
| Maximale Anzahl der Spark-Executors | (DPU - 1) \$1 2 - 1 | (NumberOfWorkers - 1) | (NumberOfWorkers - 1) |
Wenn Ihr Entwicklungsendpunkt beispielsweise 10 Worker aufweist und der Worker-Typ ` G.1X` ist, haben Sie 9 Spark-Executors und der gesamte Cluster hat 90G Executor-Speicher, da jeder Executor 10G Speicher haben wird.
Unabhängig vom angegebenen Worker-Typ wird die dynamische Ressourcenzuweisung von Spark aktiviert. Wenn ein Datensatz groß genug ist, kann Spark alle Executors einer einzelnen Livy-Sitzung zuweisen, da `spark.dynamicAllocation.maxExecutors` nicht standardmäßig festgelegt ist. Das bedeutet, dass andere Livy-Sitzungen auf demselben Entwicklungsendpunkt warten, um neue Executors zu starten. Ist der Datensatz klein, können Executors mehreren Livy-Sitzungen gleichzeitig zugewiesen werden.
**Anmerkung**
Weitere Informationen dazu, wie Ressourcen in verschiedenen Anwendungsfällen zugewiesen werden und wie Sie eine Konfiguration festlegen, um das Verhalten zu ändern, finden Sie unter [Erweiterte Konfiguration: Freigeben von Entwicklungsendpunkten unter mehreren Benutzern](dev-endpoint-sharing.md).
# Hinzufügen eines Entwicklungsendpunkts
Sie verwenden Entwicklungsendpunkte, um Ihre Skripts zum Extrahieren, Transformieren und Laden (Extract, Transform and Load, ETL) in AWS Glue iterativ zu entwickeln und zu testen. Die Arbeit mit Entwicklungsendpunkten ist nur über die AWS Command Line Interface verfügbar.
1. Geben Sie in einem Befehlszeilenfenster einen Befehl wie den folgenden ein.
```
aws glue create-dev-endpoint --endpoint-name "endpoint1" --role-arn "arn:aws:iam::account-id:role/role-name" --number-of-nodes "3" --glue-version "1.0" --arguments '{"GLUE_PYTHON_VERSION": "3"}' --region "region-name"
```
Dieser Befehl gibt AWS Glue Version 1.0 an. Da diese Version sowohl Python 2 als auch Python 3 unterstützt, können Sie den Parameter `arguments` verwenden, um die gewünschte Python-Version anzugeben. Wenn der Parameter `glue-version` ausgelassen wird, wird AWS Glue Version 0.9 verwendet. Weitere Informationen zu AWS Glue-Versionen finden Sie unter [Glue version job property](add-job.md#glue-version-table).
Informationen zu zusätzlichen Befehlszeilenparametern finden Sie [create-dev-endpoint](https://docs.aws.amazon.com/cli/latest/reference/glue/create-dev-endpoint.html)in der *AWS CLI Befehlsreferenz*.
1. (Optional) Geben Sie den folgenden Befehl ein, um den Status des Entwicklungsendpunkts zu überprüfen. Wenn der Status in `READY` geändert wird, können Sie den Entwicklungsendpunkt verwenden.
```
aws glue get-dev-endpoint --endpoint-name "endpoint1"
```
# Zugreifen auf den Entwicklungsendpunkt
Wenn Sie einen Entwicklungsendpunkt in einer Virtual Private Cloud (VPC) erstellen, gibt AWS Glue lediglich eine private IP-Adresse zurück. Das Feld für die öffentliche IP-Adresse wird nicht ausgefüllt. Wenn Sie einen Nicht-VPC-Entwicklungsendpunkt erstellen, gibt AWS Glue nur eine öffentliche IP-Adresse zurück.
Wenn Ihr Entwicklungsendpunkt eine **Public address (Öffentliche Adresse)** besitzt, überprüfen Sie, ob er mit dem privaten SSH-Schlüssel für den Entwicklungsendpunkt erreichbar ist, wie im folgenden Beispiel gezeigt.
```
ssh -i dev-endpoint-private-key.pem glue@public-address
```
Angenommen, Ihr Entwicklungsendpunkt besitzt eine **Private address (Private Adresse)**, Ihr VPC-Subnetz ist über das öffentliche Internet erreichbar und seine Sicherheitsgruppen unterstützen den eingehenden Zugriff über Ihren Client. In diesem Fall führen Sie die folgenden Schritte aus, um einem Entwicklungsendpunkt eine *elastische IP-Adresse* anzufügen, sodass der Zugriff aus dem Internet unterstützt wird.
**Anmerkung**
Wenn Sie elastische IP-Adressen verwenden möchten, benötigt das verwendete Subnetz einen über die Routing-Tabelle verknüpften Internet-Gateway.
**So greifen Sie durch Anfügen einer elastischen IP-Adresse auf einen Entwicklungsendpunkt zu**
1. Öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Wählen Sie im Navigationsbereich **Dev endpoints (Entwicklungsendpunkte)** aus und navigieren Sie zur Detailseite des Entwicklungsendpunkts. Notieren Sie die **Private address** (Private Adresse) für den nächsten Schritt.
1. Öffnen Sie die EC2 Amazon-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Klicken Sie im Navigationsbereich unter **Network & Security (Netzwerk und Sicherheit)** auf **Network Interfaces (Netzwerkschnittstellen)**.
1. Suchen Sie auf der Detailseite des Entwicklungsendpunkts der AWS Glue Konsole nach dem **privaten DNS (IPv4)****, der der privaten Adresse** entspricht.
Möglicherweise müssen Sie ändern, welche Spalten auf Ihrer EC2 Amazon-Konsole angezeigt werden. Beachten Sie die **Network interface ID (Netzwerkschnittstellen-ID)** (ENI) für diese Adresse (z. B. `eni-12345678`).
1. Wählen Sie auf der EC2 Amazon-Konsole unter **Network & Security** die Option **Elastic** aus IPs.
1. Wählen Sie **Allocate new address (Neue Adresse zuweisen)** und dann **Allocate (Zuweisen)** aus, um eine neue elastische IP-Adresse zuzuweisen.
1. Wählen Sie auf der ** IPsElastic-Seite** die neu zugewiesene **Elastic IP** aus. Wählen Sie dann **Actions** (Aktionen) und anschließend **Associate address** (Adresse zuweisen) aus.
1. Führen Sie auf der Seite **Associate address (Adresse zuordnen)** die folgenden Schritte aus:
+ Wählen Sie für **Resource type** (Ressourcentyp) **Network interface** (Netzwerkschnittstelle) aus.
+ Geben Sie im Feld **Network interface (Netzwerkschnittstelle)** die **Network interface ID (Netzwerk-Schnittstellen-ID)** (ENI) für die private Adresse ein.
+ Wählen Sie **Associate** aus.
1. Überprüfen Sie, ob die neu zugeordnete elastische IP-Adresse mit dem privaten, dem Entwicklungsendpunkt zugeordneten SSH-Schlüssel erreichbar ist, wie im folgenden Beispiel gezeigt.
```
ssh -i dev-endpoint-private-key.pem glue@elastic-ip
```
Informationen zur Verwendung eines Bastion-Hosts, um SSH-Zugriff auf die private Adresse des Entwicklungsendpunkts zu erhalten, finden Sie im AWS Sicherheits-Blogbeitrag [Securely Connect to Linux Instances Running in a Private Amazon](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/) VPC.
# 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.
# Tutorial: Verwenden Sie ein SageMaker KI-Notizbuch mit Ihrem Entwicklungsendpunkt
In AWS Glue können Sie einen Entwicklungsendpunkt und anschließend ein SageMaker KI-Notizbuch erstellen, um Sie bei der Entwicklung Ihrer ETL- und Machine-Learning-Skripte zu unterstützen. Ein SageMaker KI-Notebook ist eine vollständig verwaltete Recheninstanz für maschinelles Lernen, auf der die Jupyter Notebook-Anwendung ausgeführt wird.
1. Klicken Sie in der AWS Glue-Konsole auf **Dev endpoints (Entwicklungsendpunkte)**, um zur Liste der Entwicklungsendpunkte zu navigieren.
1. **Aktivieren Sie das Kontrollkästchen neben dem Namen eines Entwicklungsendpunkts, den Sie verwenden möchten, und wählen Sie im Menü **Aktion** die Option Notizbuch erstellen aus. SageMaker**
1. Füllen Sie die Seite **Create and configure a notebook (Notebook erstellen und konfigurieren)** wie folgt aus:
1. Geben Sie einen Namen für das Notebook ein.
1. Überprüfen Sie unter **Attach to development endpoint (An Entwicklungsendpunkt anfügen)** den Entwicklungsendpunkt.
1. Erstellen Sie eine AWS Identity and Access Management (IAM-) Rolle, oder wählen Sie sie aus.
Es wird empfohlen, eine Rolle zu erstellen. Wenn Sie eine vorhandene Rolle verwenden, stellen Sie sicher, dass sie über die erforderlichen Berechtigungen verfügt. Weitere Informationen finden Sie unter [Schritt 6: Erstellen Sie eine IAM-Richtlinie für SageMaker KI-Notebooks](create-sagemaker-notebook-policy.md).
1. (Optional) Wählen Sie eine VPC, ein Subnetz und eine oder mehrere Sicherheitsgruppen aus.
1. (Optional) Wählen Sie einen AWS Key Management Service Verschlüsselungsschlüssel.
1. (Optional) Fügen Sie Tags für die Notebook-Instance hinzu.
1. Klicken Sie auf **Create Notebook (Notebook erstellen)**. Wählen Sie auf der Seite **Notebooks** das Aktualisierungssymbol oben rechts aus, und fahren Sie fort, bis der **Status** angezeigt wird `Ready`.
1. Aktivieren Sie das Kontrollkästchen neben dem neuen Notebooknamen, und wählen Sie **Open notebook (Notebook öffnen)**.
1. Erstellen Sie ein neues Notizbuch: Wählen Sie auf der **Jupyter-Seite** **Neu** und dann **Sparkmagic** (). PySpark
Ihr Bildschirm sollte jetzt wie folgt aussehen.
![\[Die Jupyter-Seite verfügt über eine Menüleiste, eine Symbolleiste und ein breites Textfeld, in das Sie Anweisungen eingeben können.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/sagemaker-notebook.png)
1. (Optional) Wählen Sie oben auf der Seite **Untitled (Ohne Titel)**, und geben Sie dem Notebook einen Namen.
1. Um eine Spark-Anwendung zu starten, geben Sie den folgenden Befehl in das Notebook ein, und wählen Sie dann in der Symbolleiste **Run (Ausführen)** aus.
```
spark
```
Nach einer kurzen Verzögerung sollten Sie die folgende Antwort sehen:
![\[Die Systemantwort zeigt den Status der Spark-Anwendung und gibt die folgende Meldung aus: verfügbar als „Spark“. SparkSession\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/spark-command-response.png)
1. Erstellen Sie einen dynamischen Frame, und führen Sie eine Abfrage aus: Kopieren, Einfügen und Ausführen des folgenden Codes, der die Anzahl und das Schema der `persons_json`-Tabelle ausgibt.
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Tutorial: Verwenden Sie eine REPL Shell mit Ihrem Entwicklungsendpunkt
In AWS Glue können Sie einen Entwicklungsendpunkt erstellen und dann eine REPL-Shell (Read—Evaluate—Print Loop) aufrufen, um PySpark Code inkrementell auszuführen, sodass Sie Ihre ETL-Skripts interaktiv debuggen können, bevor Sie sie bereitstellen.
Um eine REPL auf einem Entwicklungsendpunkt verwenden zu können, benötigen Sie eine SSH-Berechtigung für den Endpunkt.
1. Öffnen Sie auf Ihrem lokalen Computer ein Terminalfenster, das SSH-Befehle ausführen kann, und fügen Sie den bearbeiteten SSH-Befehl ein. Führen Sie den Befehl aus.
Angenommen, Sie haben AWS Glue-Version 1.0 mit Python 3 für den Entwicklungsendpunkt akzeptiert, sieht die Ausgabe wie folgt aus:
```
Python 3.6.8 (default, Aug 2 2019, 17:42:44)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux
Type "help", "copyright", "credits" or "license" for more information.
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/usr/share/aws/glue/etl/jars/glue-assembly.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/usr/lib/spark/jars/slf4j-log4j12-1.7.16.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
2019-09-23 22:12:23,071 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Neither spark.yarn.jars nor spark.yarn.archive is set, falling back to uploading libraries under SPARK_HOME.
2019-09-23 22:12:26,562 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same name resource file:/usr/lib/spark/python/lib/pyspark.zip added multiple times to distributed cache
2019-09-23 22:12:26,580 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/etl/python/PyGlue.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/lib/spark/python/lib/py4j-src.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/libs/pyspark.zip added multiple times to distributed cache.
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/__ / .__/\_,_/_/ /_/\_\ version 2.4.3
/_/
Using Python version 3.6.8 (default, Aug 2 2019 17:42:44)
SparkSession available as 'spark'.
>>>
```
1. Testen Sie, ob die REPL Shell ordnungsgemäß funktioniert, indem Sie die Anweisung `print(spark.version)` eingeben. Solange dies die Spark-Version anzeigt, ist Ihre REPL jetzt einsatzbereit.
1. Sie können nun versuchen, das folgende einfache Skript zeilenweise in der Shell auszuführen:
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Tutorial: PyCharm Professional mit einem Entwicklungsendpunkt einrichten
Dieses Tutorial zeigt Ihnen, wie Sie die [PyCharm Professional](https://www.jetbrains.com/pycharm/) Python IDE, die auf Ihrem lokalen Computer ausgeführt wird, mit einem Entwicklungsendpunkt verbinden, sodass Sie AWS Glue ETL-Skripts (Extrahieren, Übertragen und Laden) interaktiv ausführen, debuggen und testen können, bevor Sie sie bereitstellen. Die Anweisungen und Screenshots im Tutorial basieren auf der PyCharm Professional-Version 2019.3.
Um eine interaktive Verbindung zu einem Entwicklungsendpunkt herzustellen, muss PyCharm Professional installiert sein. Dies können Sie nicht mit der kostenlosen Version durchführen.
**Anmerkung**
Im Tutorial wird Amazon S3 als Datenquelle verwendet. Wenn Sie stattdessen eine JDBC-Datenquelle verwenden möchten, müssen Sie Ihren Entwicklungsendpunkt in einer Virtual Private Cloud (VPC) ausführen. Um eine Verbindung mit SSH zu einem Entwicklungsendpunkt in einer VPC herzustellen, müssen Sie einen SSH-Tunnel erstellen. Dieses Tutorial enthält keine Anweisungen zum Erstellen eines SSH-Tunnels. Informationen zur Verwendung von SSH für die Connect mit einem Entwicklungsendpunkt in einer VPC finden Sie unter [Sichere Verbindung zu Linux-Instances, die in einer privaten Amazon-VPC ausgeführt](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/) werden, im AWS Sicherheitsblog.
**Topics**
+ [PyCharm Professionelle Verbindung zu einem Entwicklungsendpunkt herstellen](#dev-endpoint-tutorial-pycharm-connect)
+ [Bereitstellen des Skripts auf Ihrem Entwicklungsendpunkt](#dev-endpoint-tutorial-pycharm-deploy)
+ [Konfigurieren eines Remote Interpreters](#dev-endpoint-tutorial-pycharm-interpreter)
+ [Ausführen Ihres Skripts auf dem Entwicklungsendpunkt](#dev-endpoint-tutorial-pycharm-debug-run)
## PyCharm Professionelle Verbindung zu einem Entwicklungsendpunkt herstellen
1. Erstellen Sie ein neues Pure-Python-Projekt in PyCharm named. `legislators`
1. Erstellen Sie im Projekt eine Datei mit dem Namen `get_person_schema.py` und dem folgenden Inhalt:
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
def main():
# 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()
if __name__ == "__main__":
main()
```
1. Führen Sie eine der folgenden Aktionen aus:
+ Laden Sie für AWS Glue 0.9 die AWS Glue-Python-Bibliotheksdatei `PyGlue.zip` von `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl/python/PyGlue.zip` in einen geeigneten Speicherort auf Ihrem lokalen Computer herunter.
+ Laden Sie für AWS Glue 1.0 und höhere Versionen die AWS Glue-Python-Bibliotheksdatei `PyGlue.zip` von `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl-1.0/python/PyGlue.zip` in einen geeigneten Speicherort auf Ihrem lokalen Computer herunter.
1. Fügen Sie `PyGlue.zip` es als Inhaltsstamm für Ihr Projekt hinzu in: PyCharm
+ Wählen Sie in PyCharm **Datei**, **Einstellungen**, um das Dialogfeld **Einstellungen** zu öffnen. (Sie können auch `Ctrl+Alt+S` betätigen.)
+ Erweitern Sie das Projekt `legislators` und wählen Sie **Project Structure** (Projektstruktur) aus. Wählen Sie anschließend auf der rechten Seite **\$1 Add Content Root** (\$1 Inhalts-Stammverzeichnis hinzufügen) aus.
+ Navigieren Sie zum Speicherort, an dem Sie `PyGlue.zip` gespeichert haben, und wählen Sie dann **Apply** (Anwenden) aus.
Der Bildschirm **Settings** (Einstellungen) sollte etwa wie folgt aussehen:
![\[Der PyCharm Einstellungsbildschirm mit der hinzugefügten PyGlue ZIP-Datei als Inhaltsstamm.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/PyCharm_AddContentRoot.png)
Lassen Sie das Dialogfeld **Settings** (Einstellungen) geöffnet, nachdem Sie **Apply** (Anwenden) ausgewählt haben.
1. Konfigurieren Sie die Bereitstellungsoptionen, um das lokale Skript mithilfe von SFTP auf Ihren Entwicklungsendpunkt hochzuladen (diese Funktion ist nur in PyCharm Professional verfügbar):
+ Erweitern Sie im Dialogfeld **Settings** (Einstellungen) den Abschnitt **Build, Execution, Deployment** (Erstellung, Ausführung, Bereitstellung). Wählen Sie den Teilabschnitt **Deployment** (Bereitstellung) aus.
+ Wählen Sie das Symbol **\$1** oben im mittleren Bereich aus, um einen neuen Server hinzuzufügen. Setzen Sie seinen **Type (Typ)** auf `SFTP`, und geben Sie ihm einen Namen.
+ Legen Sie den **SFTP-Host** auf die **Public Address (Öffentliche Adresse)** Ihres Entwicklungsendpunkts fest, wie auf der Detailseite aufgeführt. (Wählen Sie den Namen Ihres Entwicklungsendpunkts in der AWS Glue-Konsole, um die Detailseite anzuzeigen). Legen Sie für einen Entwicklungsendpunkt, der in einer VPC ausgeführt wird, den **SFTP-Host** auf die Hostadresse und den lokalen Port des SSH-Tunnels auf den Entwicklungsendpunkt fest.
+ Legen Sie den **User name** (Benutzername) auf `glue` fest.
+ Legen Sie den **Auth type** (Authentifizierungstyp) auf **Key pair (OpenSSH or Putty)** (Schlüsselpaar (OpenSSH oder PuTTY)) fest. Legen Sie die **Private key file** (Datei für den privaten Schlüssel) fest, indem Sie zum Speicherort navigieren, an dem die Datei für den privaten Schlüssel Ihres Entwicklungsendpunkts gespeichert ist. Beachten Sie, dass PyCharm nur die OpenSSH-Schlüsseltypen DSA, RSA und ECDSA unterstützt werden und keine Schlüssel im privaten Format von Putty akzeptiert. Sie können eine up-to-date Version von verwenden, um einen Schlüsselpaartyp `ssh-keygen` zu generieren, der akzeptiert, und zwar mit einer Syntax wie der folgenden: PyCharm
```
ssh-keygen -t rsa -f -C ""
```
+ Wählen Sie **Test SFTP connection (SFTP-Verbindung testen)** aus, und lassen Sie das Testen der Verbindung zu. Wenn die Verbindung erfolgreich hergestellt wird, wählen Sie **Apply** (Anwenden) aus.
Der Bildschirm **Settings** (Einstellungen) sollte nun etwa wie folgt aussehen:
![\[Der PyCharm Einstellungsbildschirm mit einem definierten SFTP-Server.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/PyCharm_SFTP.png)
Lassen Sie wiederum das Dialogfeld **Settings** (Einstellungen) geöffnet, nachdem Sie **Apply** (Anwenden) ausgewählt haben.
1. Ordnen Sie das lokale Verzeichnis einem Remote-Verzeichnis für die Bereitstellung zu:
+ Wählen Sie rechts auf der Seite **Deployment** (Bereitstellung) die mittlere Registerkarte mit der Bezeichnung **Mappings** aus.
+ Geben Sie in der Spalte **Deployment Path** (Bereitstellungspfad) einen Pfad für die Bereitstellung Ihres Projekts unter `/home/glue/scripts/` ein. Beispiel: `/home/glue/scripts/legislators`.
+ Wählen Sie **Anwenden** aus.
Der Bildschirm **Settings** (Einstellungen) sollte nun etwa wie folgt aussehen:
![\[Der PyCharm Einstellungsbildschirm nach einer Bereitstellungszuweisung.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/PyCharm_Mapping.png)
Klicken Sie auf **OK**, um das Dialogfeld ** Settings (Einstellungen)** zu schließen.
## Bereitstellen des Skripts auf Ihrem Entwicklungsendpunkt
1. Wählen Sie **Tools (Extras)**, **Deployment (Bereitstellung)**, und wählen Sie dann den Namen, unter dem Sie Ihren Entwicklungsendpunkt einrichten, wie im folgenden Image dargestellt:
![\[Die Menüoption zur Bereitstellung Ihres Skripts.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/PyCharm_Deploy.png)
Nachdem Ihr Skript bereitgestellt wurde, sollte der untere Bereich des Bildschirms etwa wie folgt aussehen:
![\[Der untere PyCharm Bildschirmrand nach einer erfolgreichen Bereitstellung.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/PyCharm_Deployed.png)
1. Wählen Sie in der Menüleiste **Tools (Extras)**, **Deployment (Bereitstellung)**, **Automatic Upload (always) (Automatischer Upload (immer))**. Stellen Sie sicher, dass neben **Automatic Upload (always) (Automatischer Upload (immer))** ein Häkchen angezeigt wird.
Wenn diese Option aktiviert ist, PyCharm werden geänderte Dateien automatisch auf den Entwicklungsendpunkt hochgeladen.
## Konfigurieren eines Remote Interpreters
Konfigurieren Sie so PyCharm , dass der Python-Interpreter auf dem Entwicklungsendpunkt verwendet wird.
1. Wählen Sie im Menü **File (Datei)** die Option **Open (Öffnen)** aus.
1. Erweitern Sie die **Project legislators (Projektgesetzgeber)**, und wählen Sie **Project Interpreter**.
1. Wählen Sie das Zahnradsymbol neben der Liste **Project Interpreter**, und wählen Sie dann **Add (Hinzufügen)**.
1. Wählen Sie im Dialogfeld **Add Python Interpreter (Python-Interpreter hinzufügen)** im linken Bereich die Option **SSH-Interpreter**.
1. Wählen Sie **Existing server configuration (Vorhandene Serverkonfiguration)**, und wählen Sie in der Liste **Deployment configuration (Bereitstellungskonfiguration)** Ihre Konfiguration aus.
Ihr Bildschirm sollte ungefähr wie das folgende Image aussehen.
![\[Im linken Bereich ist SSH-Interpreter ausgewählt, und im rechten Bereich ist das Optionsfeld „Existing server configuration (Vorhandene Serverkonfiguration)“ aktiviert. Das Feld „Deployment configuration (Bereitstellungskonfiguration)“ enthält den Konfigurationsnamen und die Meldung „Remote SDK is saved in IDE settings, so it needs the deployment server to be saved there too. Which do you prefer? (Remote-SDK wird in IDE-Einstellungen gespeichert. Daher muss auch der Bereitstellungsserver dort gespeichert werden.Was bevorzugen Sie?)“. Folgende Optionen stehen unter dieser Meldung zur Auswahl: „Create copy of this deployment server in IDE settings (Kopie dieses Bereitstellungsservers in IDE-Einstellungen erstellen)“ und „Move this server to IDE settings. (Diesen Server in IDE-Einstellungen verschieben)“.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/PyCharm_Interpreter1.png)
1. Wählen Sie **Move this server to IDE settings (Diesen Server in IDE-Einstellungen verschieben)** und dann **Next (Weiter)**.
1. Ändern Sie im Feld **Interpreter** den Pfad zu ` /usr/bin/gluepython`, wenn Sie Python 2 verwenden, oder zu `/usr/bin/gluepython3`, wenn Sie Python 3 verwenden. Klicken Sie auf **Finish (Fertig stellen)**.
## Ausführen Ihres Skripts auf dem Entwicklungsendpunkt
So führen Sie das Skript aus:
+ Klicken Sie im linken Bereich mit der rechten Maustaste auf den Dateinamen und wählen Sie **Ausführen '**'** aus.
Nach einer Reihe von Nachrichten sollte die endgültige Ausgabe die Anzahl und das Schema anzeigen.
```
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
| | |-- lang: string
| | |-- note: string
| | |-- name: 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
Process finished with exit code 0
```
Nun können Sie Ihr Skript remote auf Ihrem Entwicklungsendpunkt debuggen.
# Erweiterte Konfiguration: Freigeben von Entwicklungsendpunkten unter mehreren Benutzern
In diesem Abschnitt wird erklärt, wie Sie in typischen Anwendungsfällen Entwicklungsendpunkte mit SageMaker Notebooks nutzen können, um Entwicklungsendpunkte für mehrere Benutzer gemeinsam zu nutzen.
## Single-Tenancy-Konfiguration
Um die Entwicklererfahrung zu vereinfachen und Ressourcenkonflikte zu vermeiden, wird in Single-Tenant-Anwendungsfällen empfohlen, dass jeder Entwickler einen eigenen Entwicklungsendpunkt verwendet, der auf sein jeweiliges Projekt ausgerichtet ist. Dies vereinfacht auch die Entscheidungen zu Worker-Typ und DPU-Anzahl, da sie je nach Projekt und Ermessen des Entwicklers eingestellt werden können.
Solange Sie nicht mehrere Notebook-Dateien gleichzeitig ausführen, müssen Sie sich nicht um die Ressourcenzuweisung kümmern. Wenn Sie Code in mehreren Notebook-Dateien gleichzeitig ausführen, werden mehrere Livy-Sitzungen parallel gestartet. Um Spark-Cluster-Konfigurationen zu trennen, sodass mehrere Livy-Sitzungen gleichzeitig ausgeführt werden können, führen Sie die Schritte aus, die in Multi-Tenant-Anwendungsfällen eingeführt werden.
Wenn Ihr Entwicklungsendpunkt beispielsweise 10 Worker aufweist und der Worker-Typ ` G.1X` ist, haben Sie 9 Spark-Executors und der gesamte Cluster hat 90G Executor-Speicher, da jeder Executor 10G Speicher haben wird.
Unabhängig vom angegebenen Worker-Typ wird die dynamische Ressourcenzuweisung von Spark aktiviert. Wenn ein Datensatz groß genug ist, kann Spark alle Executors einer einzelnen Livy-Sitzung zuweisen, da `spark.dynamicAllocation.maxExecutors` nicht standardmäßig festgelegt ist. Das bedeutet, dass andere Livy-Sitzungen auf demselben Entwicklungsendpunkt warten, um neue Executors zu starten. Ist der Datensatz klein, können Executors mehreren Livy-Sitzungen gleichzeitig zugewiesen werden.
**Anmerkung**
Weitere Informationen dazu, wie Ressourcen in verschiedenen Anwendungsfällen zugewiesen werden und wie Sie eine Konfiguration festlegen, um das Verhalten zu ändern, finden Sie unter [Erweiterte Konfiguration: Freigeben von Entwicklungsendpunkten unter mehreren Benutzern](#dev-endpoint-sharing).
### Multi-Tenancy-Konfiguration
**Anmerkung**
Bitte beachten Sie, dass Entwicklungsendpunkte die AWS Glue-ETL-Umgebung als Single-Tenant-Umgebung emulieren sollen. Multi-Tenancy ist zwar möglich, ist jedoch ein erweiterter Anwendungsfall. In der Regel wird empfohlen, dass die Benutzer für jeden Entwicklungsendpunkt ein Single-Tenancy-Muster beibehalten.
In Multi-Tenant-Anwendungsfällen müssen Sie sich gegebenenfalls um die Ressourcenzuweisung kümmern. Der entscheidende Faktor ist die Anzahl der Benutzer, die ein Jupyter Notebook gleichzeitig verwenden. Wenn Ihr Team in einem "follow-the-sun" Workflow arbeitet und es in jeder Zeitzone nur einen Jupyter-Benutzer gibt, dann ist die Anzahl der gleichzeitigen Benutzer nur eins, sodass Sie sich keine Gedanken über die Ressourcenzuweisung machen müssen. Wird Ihr Notebook jedoch von mehreren Benutzern gemeinsam genutzt und jeder Benutzer reicht Code auf einer Ad-hoc-Basis ein, müssen Sie die folgenden Punkte berücksichtigen.
Um Spark-Cluster-Ressourcen auf mehrere Benutzer aufzuteilen, können Sie Konfigurationen verwenden. SparkMagic Es gibt zwei verschiedene Arten der Konfiguration SparkMagic.
#### (A) Verwenden der Anweisung %%configure -f
Wenn Sie die Konfiguration pro Livy-Sitzung des Notebooks ändern möchten, können Sie die Anweisung `%%configure -f` für den Notebook-Abschnitt ausführen.
Soll beispielsweise eine Spark-Anwendung auf 5 Executors ausgeführt werden, können Sie für den Notebook-Abschnitt den folgenden Befehl ausführen.
```
%%configure -f
{"numExecutors":5}
```
Sie sehen dann nur 5 Executors, die für den Auftrag in der Spark-Benutzeroberfläche ausgeführt werden.
Wir empfehlen, die maximale Anzahl von Executors für die dynamische Ressourcenzuweisung zu begrenzen.
```
%%configure -f
{"conf":{"spark.dynamicAllocation.maxExecutors":"5"}}
```
#### (B) Ändern Sie die SparkMagic Konfigurationsdatei
SparkMagic funktioniert basierend auf der [Livy-API](https://livy.incubator.apache.org/docs/latest/rest-api.html). SparkMagic erstellt Livy-Sitzungen mit Konfigurationen wie`driverMemory`,` driverCores`,,`executorMemory`,`executorCores`, ` numExecutors``conf`, usw. Dies sind die Schlüsselfaktoren, die bestimmen, wie viele Ressourcen vom gesamten Spark-Cluster verbraucht werden. SparkMagic ermöglicht es Ihnen, eine Konfigurationsdatei bereitzustellen, um die Parameter anzugeben, die an Livy gesendet werden. In diesem [GitHub-Repository](https://github.com/jupyter-incubator/sparkmagic/blob/master/sparkmagic/example_config.json) können Sie sich eine Beispielkonfigurationsdatei ansehen.
Wenn Sie die Konfiguration für alle Livy-Sitzungen eines Notebooks ändern möchten, können Sie `/home/ec2-user/.sparkmagic/config.json` anpassen, indem Sie `session_config` hinzufügen.
Um die Konfigurationsdatei auf einer SageMaker Notebook-Instanz zu ändern, können Sie die folgenden Schritte ausführen.
1. Öffnen Sie ein SageMaker Notizbuch.
1. Öffnen Sie den Terminalkernel.
1. Führen Sie die folgenden Befehle aus:
```
sh-4.2$ cd .sparkmagic
sh-4.2$ ls
config.json logs
sh-4.2$ sudo vim config.json
```
Sie können ` /home/ec2-user/.sparkmagic/config.json` beispielsweise diese Zeilen hinzufügen und den Jupyter-Kernel des Notebooks neu starten.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
### Leitlinien und Bewährte Methoden
Um diesen Ressourcenkonflikt zu vermeiden, können Sie unter anderem diese grundlegenden Ansätze nutzen:
+ Vergrößern Sie den Spark-Cluster, indem Sie die `NumberOfWorkers` erhöhen (horizontale Skalierung) und den `workerType` upgraden (vertikale Skalierung).
+ Weisen Sie weniger Ressourcen pro Benutzer zu (weniger Ressourcen pro Livy-Sitzung).
Ihr Ansatz hängt vom Anwendungsfall ab. Wenn Sie einen größeren Entwicklungsendpunkt haben und keine großen Datenmengen vorliegen, ist das Risiko eines Ressourcenkonflikts wesentlich geringer, da Spark Ressourcen basierend auf einer dynamischen Zuweisungsstrategie zuteilen kann.
Die Anzahl der Spark-Executors kann wie oben beschrieben anhand einer Kombination aus DPU (oder `NumberOfWorkers`) und Worker-Typ automatisch berechnet werden. Jede Spark-Anwendung startet einen Treiber und mehrere Executors. Zur Berechnung muss Folgendes gegeben sein: ` NumberOfWorkers` = `NumberOfExecutors + 1`. In der folgenden Matrix wird erläutert, wie viel Kapazität Sie basierend auf der Anzahl der gleichzeitigen Benutzer in Ihrem Entwicklungsendpunkt benötigen.
****
| Anzahl gleichzeitiger Notebook-Benutzer | Anzahl der Spark-Executors, die pro Benutzer zugewiesen werden sollen | Summe NumberOfWorkers für Ihren Entwickler-Endpunkt |
| --- | --- | --- |
| 3 | 5 | 18 |
| 10 | 5 | 60 |
| 50 | 5 | 300 |
Wenn Sie weniger Ressourcen pro Benutzer zuweisen möchten, wäre ` spark.dynamicAllocation.maxExecutors` (oder `numExecutors`) der einfachste Parameter zur Konfiguration als Livy-Sitzungsparameter. Wenn Sie die folgende Konfiguration einstellen`/home/ec2-user/.sparkmagic/config.json`, SparkMagic werden pro Livy-Sitzung maximal 5 Executoren zugewiesen. Das hilft Ihnen, die Ressourcen pro Livy-Sitzung zu trennen.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
Angenommen, Sie haben einen Entwicklungsendpunkt mit 18 Workern (G.1X) und es gibt 3 gleichzeitige Notebook-Benutzer. Wenn Ihre Sitzungskonfiguration über den Parameter ` spark.dynamicAllocation.maxExecutors=5` verfügt, kann jeder Benutzer 1 Treiber und 5 Executors nutzen. Selbst wenn Sie mehrere Notebook-Abschnitte gleichzeitig ausführen, treten keine Ressourcenkonflikte auf.
#### Nachteile
Mit dieser Sitzungskonfiguration (`"spark.dynamicAllocation.maxExecutors":"5"`) können Sie Fehler aufgrund von Ressourcenkonflikten vermeiden und müssen nicht auf die Ressourcenzuweisung warten, wenn mehrere Benutzerzugriffe gleichzeitig erfolgen. Allerdings kann Spark niemals mehr als 5 Executors für Ihre Livy-Sitzung zuweisen, selbst wenn viele freie Ressourcen verfügbar sind (z. B. weile keine anderen gleichzeitigen Benutzer vorliegen).
#### Sonstige Hinweise
Es wird empfohlen, den Jupyter-Kernel zu beenden, wenn Sie ein Notebook nicht mehr verwenden. Dadurch werden Ressourcen freigegeben, die andere Notebook-Benutzer sofort nutzen können, ohne auf den Ablauf des Kernels (automatisches Herunterfahren) warten zu müssen.
### Häufige Probleme
Auch wenn Sie die Richtlinien befolgen, können bestimmte Probleme auftreten.
#### Sitzung nicht gefunden
Wenn Sie versuchen, einen Notebook-Abschnitt auszuführen, obwohl Ihre Livy-Sitzung bereits beendet wurde, wird die folgende Meldung angezeigt. Um die Livy-Sitzung zu aktivieren, müssen Sie den Jupyter-Kernel neu starten. Dazu gehen Sie im Jupyter-Menü auf **Kernel** > **Restart (Neustart)** und führen anschließend den Notebook-Abschnitt erneut aus.
```
An error was encountered:
Invalid status code '404' from http://localhost:8998/sessions/13 with error payload: "Session '13' not found."
```
#### Nicht genügend YARN-Ressourcen
Wenn Sie versuchen, einen Notebook-Abschnitt auszuführen, obwohl Ihr Spark-Cluster nicht über genügend Ressourcen verfügt, um eine neue Livy-Sitzung zu starten, wird die folgende Meldung angezeigt. Oft können Sie dieses Problem vermeiden, wenn Sie die Richtlinien einhalten. Trotzdem besteht die Möglichkeit, dass dieses Problem auftritt. Als Workaround können Sie überprüfen, ob nicht benötigte aktive Livy-Sitzungen vorhanden sind. Diese sollten beendet werden, um die Clusterressourcen freizugeben. Details finden Sie im nächsten Abschnitt.
```
Warning: The Spark session does not have enough YARN resources to start.
The code failed because of a fatal error:
Session 16 did not start up in 60 seconds..
Some things to try:
a) Make sure Spark has enough available resources for Jupyter to create a Spark context.
b) Contact your Jupyter administrator to make sure the Spark magics library is configured correctly.
c) Restart the kernel.
```
### Überwachung und Debugging
In diesem Abschnitt werden Methoden für die Überwachung von Ressourcen und Sitzungen beschrieben.
#### Überwachen und Debuggen der Zuweisung von Clusterressourcen
Sie können die Spark-Benutzeroberfläche beobachten, um zu überwachen, wie viele Ressourcen pro Livy-Sitzung zugewiesen werden und welche Spark-Konfigurationen für den Auftrag am effektivsten sind. Informationen zum Aktivieren der Spark-Benutzeroberfläche finden Sie unter [Aktivieren der Apache-Spark-Webbenutzeroberfläche für Entwicklungsendpunkte](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-dev-endpoints.html).
(Optional) Wenn Sie eine Echtzeitansicht der Spark-Benutzeroberfläche benötigen, können Sie einen SSH-Tunnel für den Spark-Verlaufsserver konfigurieren, der auf dem Spark-Cluster ausgeführt wird.
```
ssh -i -N -L 8157::18080 glue@
```
Dann können Sie http://localhost:8157 in Ihrem Browser öffnen, um die Spark-Benutzeroberfläche aufzurufen.
#### Kostenlose, nicht benötigte Livy-Sitzungen
Sehen Sie sich diese Verfahren an, mit denen nicht benötigte Livy-Sitzungen in einem Notebook oder Spark-Cluster beendet werden.
**(a). Beenden von Livy-Sitzungen in einem Notebook**
Sie können den Kernel in einem Jupyter Notebook herunterfahren, um nicht benötigte Livy-Sitzungen zu beenden.
**(b). Beenden von Livy-Sitzungen in einem Spark-Cluster**
Wenn noch nicht benötigte Livy-Sitzungen ausgeführt werden, können Sie diese im Spark-Cluster beenden.
Als Voraussetzung für dieses Verfahren müssen Sie den öffentlichen SSH-Schlüssel für Ihren Entwicklungsendpunkt konfigurieren.
Zur Anmeldung beim Spark-Cluster können Sie den folgenden Befehl ausführen:
```
$ ssh -i glue@
```
Mit dem folgenden Befehl können Sie die aktiven Livy-Sitzungen anzeigen:
```
$ yarn application -list
20/09/25 06:22:21 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/172.38.106.206:8032
Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):2
Application-Id Application-Name Application-Type User Queue State Final-State Progress Tracking-URL
application_1601003432160_0005 livy-session-4 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-4-130.ec2.internal:41867
application_1601003432160_0004 livy-session-3 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-179-185.ec2.internal:33727
```
Anschließend können Sie die Livy-Sitzungen mit dem folgenden Befehl beenden:
```
$ yarn application -kill application_1601003432160_0005
20/09/25 06:23:38 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/255.1.106.206:8032
Killing application application_1601003432160_0005
20/09/25 06:23:39 INFO impl.YarnClientImpl: Killed application application_1601003432160_0005
```
# Verwalten von Notebooks
**Anmerkung**
Entwicklungsendpunkte werden nur für Versionen AWS Glue vor 2.0 unterstützt. Für eine interaktive Umgebung, in der Sie ETL-Skripts erstellen und testen können, verwenden Sie [Notebooks on AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html).
Ein Notizbuch ermöglicht die interaktive Entwicklung und das Testen Ihrer ETL-Skripts (Extrahieren, Transformieren und Laden) auf einem Entwicklungsendpunkt. AWS Gluebietet eine Schnittstelle zu SageMaker AI Jupyter-Notebooks. Mit AWS Glue erstellen und verwalten SageMaker Sie KI-Notizbücher. Sie können SageMaker KI-Notizbücher auch von der AWS Glue Konsole aus öffnen.
Darüber hinaus können Sie Apache Spark mit SageMaker KI auf AWS Glue Entwicklungsendpunkten verwenden, die SageMaker KI unterstützen (aber keine AWS Glue ETL-Jobs). SageMaker Spark ist eine Open-Source-Apache Spark-Bibliothek für SageMaker KI. Weitere Informationen finden Sie unter [Verwenden von Apache Spark mit Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/apache-spark.html).
| Region | Code |
| --- | --- |
| Die Verwaltung von SageMaker KI-Notebooks mit AWS Glue Entwicklungsendpunkten ist in den folgenden AWS Regionen verfügbar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/notebooks-with-glue.html) |
| US East (Ohio) | `us-east-2` |
| USA Ost (Nord-Virginia) | `us-east-1` |
| USA West (Nordkalifornien) | `us-west-1` |
| USA West (Oregon) | `us-west-2` |
| Asien-Pazifik (Tokio) | `ap-northeast-1` |
| Asien-Pazifik (Seoul) | `ap-northeast-2` |
| Asien-Pazifik (Mumbai) | `ap-south-1` |
| Asien-Pazifik (Singapur) | `ap-southeast-1` |
| Asien-Pazifik (Sydney) | `ap-southeast-2` |
| Kanada (Zentral) | `ca-central-1` |
| Europe (Frankfurt) | `eu-central-1` |
| Europa (Irland) | `eu-west-1` |
| Europa (London) | `eu-west-2` |
**Topics**