Entwickeln mit AWS Glue Studio Entwickeln mit interaktiven Sitzungen Entwickeln mit einem Docker-Image Entwickeln mit der AWS Glue-ETL-Bibliothek

Lokales Entwickeln und Testen von AWS Glue-Auftrags-Skripts

Beim Entwickeln und Testen von AWS Glue-für-Spark-Auftragsskripts stehen Ihnen mehrere Optionen zur Verfügung:

AWS Glue Studio-Konsole
- Visual editor (Visueller Editor)
- Skript-Editor
- AWS Glue Studio-Notebook
Interaktive Sitzungen
- Jupyter Notebook
Docker-Image
- Lokale Entwicklung
- Remote-Entwicklung
AWS Glue Studio-ETL-Bibliothek
- Lokale Entwicklung

Sie können eine der oben genannten Optionen entsprechend Ihren Anforderungen auswählen.

Wenn Sie keine oder geringere Code-Erfahrung bevorzugen, ist der visuelle Editor von AWS Glue Studio eine gute Wahl.

Wenn Sie ein interaktives Notebook-Erlebnis bevorzugen, empfiehlt sich AWS Glue Studio Notebook. Weitere Informationen finden Sie unter Verwenden von Notebooks mit AWS Glue Studio und AWS Glue. Wenn Sie Ihre eigene lokale Umgebung nutzen möchten, sind interaktive Sitzungen eine gute Wahl. Weitere Informationen finden Sie unter Verwenden von interaktiven Sitzungen mit AWS Glue.

Wenn Sie lokale Entwicklungserfahrung bevorzugen, ist das Docker-Image eine gute Wahl. Damit können Sie das AWS-Glue-für-Spark-Auftragsskript dort entwickeln und testen, wo Sie möchten, ohne dass AWS Glue-Kosten anfallen.

Wenn Sie eine lokale Entwicklung ohne Docker bevorzugen, ist die Installation des AWS Glue-ETL-Bibliotheksverzeichnisses eine gute Wahl.

Entwickeln mit AWS Glue Studio

Der visuelle Editor von AWS Glue Studio ist eine grafische Oberfläche, mit der Sie ETL-Aufträge (Extract, Transform, Load) in AWS Glue ganz einfach erstellen, ausführen und überwachen können. Sie können Workflows für die Datentransformation visuell erstellen und nahtlos auf der Apache-Spark-basierten Serverless-ETL-Engine von AWS Glue laufen lassen. Sie können das Schema und die Datenergebnisse in jedem Schritt des Auftrags überprüfen. Weitere Informationen finden Sie im AWS Glue Studio-Benutzerhandbuch.

Entwickeln mit interaktiven Sitzungen

Mit interaktiven Sitzungen können Sie Anwendungen aus der Umgebung Ihrer Wahl erstellen und testen. Weitere Informationen finden Sie unter Verwenden von interaktiven Sitzungen mit AWS Glue.

Entwickeln mit einem Docker-Image

Anmerkung

Die Anweisungen in diesem Abschnitt wurden unter Microsoft-Windows-Betriebssystemen nicht getestet.

Informationen zur lokalen Entwicklung und zum Testen auf Windows-Plattformen finden Sie im Blog Building an AWS Glue ETL pipeline locally without an AWS account

Für eine produktionsfähige Datenplattform sind der Entwicklungsprozess und die CI/CD-Pipeline für AWS Glue-Aufträge ein zentrales Thema. Sie können AWS Glue-Aufträge in einem Docker-Container flexibel entwickeln und testen. AWS Glue hostet Docker-Images auf Docker Hub, um Ihre Entwicklungsumgebung mit zusätzlichen Dienstprogrammen einzurichten. Sie können Ihre bevorzugte IDE, Ihr Notebook oder eine REPL mit der AWS Glue-ETL-Bibliothek verwenden. In diesem Thema wird beschrieben, wie Sie Aufträge für AWS Glue-Version 4.0 in einem Docker-Container mithilfe eines Docker-Images entwickeln und testen.

Folgende Docker-Images sind für AWS Glue auf Docker Hub verfügbar.

Für AWS Glue-Version 4.0: amazon/aws-glue-libs:glue_libs_4.0.0_image_01
Für AWS Glue Version 3.0: amazon/aws-glue-libs:glue_libs_3.0.0_image_01
Für AWS Glue Version 2.0: amazon/aws-glue-libs:glue_libs_2.0.0_image_01

Diese Images sind für x86_64 bestimmt. Es wird empfohlen, in dieser Architektur zu testen. Es ist jedoch möglich, eine lokale Entwicklungslösung auf nicht unterstützten Basis-Images zu überarbeiten.

Dieses Beispiel beschreibt die Verwendung von amazon/aws-glue-libs:glue_libs_4.0.0_image_01 und das Ausführen des Containers auf einem lokalen Computer. Dieses Container Image wurde für Spark-Aufträge der AWS Glue-Version 3.3 getestet. Dieses Image enthält Folgendes:

Amazon Linux
AWS Glue-ETL-Bibliothek (aws-glue-libs)
Apache Spark 3.3.0
Spark History Server
Jupyter Lab
Livy
Andere Bibliotheksabhängigkeiten (der gleiche Satz wie der des AWS Glue-Auftragssystems)

Komplettieren Sie entsprechend Ihren Anforderungen einen der folgenden Abschnitte:

Einrichten des Containers für die Verwendung von spark-submit
Einrichten des Containers für die Verwendung der REPL-Shell (PySpark)
Einrichten des Containers für die Verwendung von Pytest
Einrichten des Containers für die Verwendung von Jupyter Lab
Einrichten des Containers für die Verwendung von Visual Studio Code

Voraussetzungen

Stellen Sie vor dem Starten sicher, dass Docker installiert ist und der Docker-Daemon ausgeführt wird. Installationsanweisungen finden Sie in der Docker-Dokumentation für Mac oder Linux. Der Computer, auf dem der Docker ausgeführt wird, hostet den AWS Glue-Container. Stellen Sie außerdem sicher, dass Sie über mindestens 7 GB Speicherplatz für das Image auf dem Host, auf dem der Docker ausgeführt wird, verfügen.

Weitere Informationen zu Einschränkungen bei der lokalen Entwicklung von AWS Glue-Code finden Sie unter Local Development Restrictions (Lokale Entwicklungseinschränkungen).

Konfigurieren von AWS

Um AWS-API-Aufrufe aus dem Container zu aktivieren, richten Sie AWS-Anmeldeinformationen über die folgenden Schritte ein. In den folgenden Abschnitten werden wir dieses Profil mit dem Namen AWS verwenden.

Richten Sie die AWS CLI ein und konfigurieren Sie ein benanntes Profil. Weitere Informationen zur AWS CLI-Konfiguration finden Sie unter Einstellungen der Konfigurations- und Anmeldeinformationsdatei in der Dokumentation zu AWS CLI.
Führen Sie den folgenden Befehl von einem Terminal aus:
```
PROFILE_NAME="<your_profile_name>"
```

Möglicherweise müssen Sie auch die Umgebungsvariable AWS_REGION festlegen, um anzugeben, an welche AWS-Region die Anforderungen gesendet werden sollen.

Einrichten und Ausführen des Containers

Das Einrichten des Containers zum Ausführen von PySpark-Code über den Befehl „spark-submit“ umfasst die folgenden allgemeinen Schritte:

Rufen Sie das Image aus Docker Hub ab.
Führen Sie den Container aus.

Abrufen des Image aus Docker Hub

Mit dem folgenden Befehl können Sie das Image aus Docker Hub abrufen:


docker pull amazon/aws-glue-libs:glue_libs_4.0.0_image_01

Ausführen des Containers

Sie können jetzt mit diesem Image einen Container ausführen. Sie können eine der folgenden Optionen entsprechend Ihren Anforderungen auswählen.

spark-submit

Sie können ein AWS Glue-Auftragsskript durch Ausführen des spark-submit-Befehls auf dem Container ausführen.

Schreiben Sie das Skript und speichern Sie es als sample1.py im /local_path_to_workspace-Verzeichnis. Sie finden Beispielcode im Anhang zu diesem Thema.


$ WORKSPACE_LOCATION=/local_path_to_workspace
$ SCRIPT_FILE_NAME=sample.py
$ mkdir -p ${WORKSPACE_LOCATION}/src
$ vim ${WORKSPACE_LOCATION}/src/${SCRIPT_FILE_NAME}

Führen Sie den folgenden Befehl aus, um den spark-submit-Befehl für den Container zum Übermitteln einer neuen Spark-Anwendung auszuführen:


$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_spark_submit amazon/aws-glue-libs:glue_libs_4.0.0_image_01 spark-submit /home/glue_user/workspace/src/$SCRIPT_FILE_NAME
...22/01/26 09:08:55 INFO DAGScheduler: Job 0 finished: fromRDD at DynamicFrame.scala:305, took 3.639886 s
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

...

(Optional) Passen Sie die Konfiguration von spark-submit an Ihre Umgebung an. Sie können beispielsweise Ihre Abhängigkeiten mit der --jars-Konfiguration übergeben. Weitere Informationen finden Sie unter Starten von Anwendungen mit spark-submit in der Spark-Dokumentation.

REPL-Shell (Pyspark)

Sie können die REPL (Read-Eval-Print-Schleifen)-Shell für die interaktive Entwicklung ausführen.

Führen Sie den folgenden Befehl aus, um den PySpark-Befehl für den Container zum Starten der REPL-Shell auszuführen:


$ docker run -it -v ~/.aws:/home/glue_user/.aws -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pyspark amazon/aws-glue-libs:glue_libs_4.0.0_image_01 pyspark
...
 ____ __
 / __/__ ___ _____/ /__
 _\ \/ _ \/ _ `/ __/ '_/
 /__ / .__/\_,_/_/ /_/\_\  version 3.1.1-amzn-0
 /_/

Using Python version 3.7.10 (default, Jun 3 2021 00:02:01)
Spark context Web UI available at http://56e99d000c99:4040
Spark context available as 'sc' (master = local[*], app id = local-1643011860812).
SparkSession available as 'spark'.
>>>

Pytest

Bei Komponententests können Sie pytest für AWS Glue-Spark-Auftragsskripts verwenden.

Führen Sie zur Vorbereitung die folgenden Befehle aus.


$ WORKSPACE_LOCATION=/local_path_to_workspace
$ SCRIPT_FILE_NAME=sample.py
$ UNIT_TEST_FILE_NAME=test_sample.py
$ mkdir -p ${WORKSPACE_LOCATION}/tests
$ vim ${WORKSPACE_LOCATION}/tests/${UNIT_TEST_FILE_NAME}

Führen Sie zum Ausführen von pytest in der Testsuite den folgenden Befehl aus:


$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pytest amazon/aws-glue-libs:glue_libs_4.0.0_image_01 -c "python3 -m pytest"
starting org.apache.spark.deploy.history.HistoryServer, logging to /home/glue_user/spark/logs/spark-glue_user-org.apache.spark.deploy.history.HistoryServer-1-5168f209bd78.out
*============================================================= test session starts =============================================================
*platform linux -- Python 3.7.10, pytest-6.2.3, py-1.11.0, pluggy-0.13.1
rootdir: /home/glue_user/workspace
plugins: anyio-3.4.0
*collected 1 item  *

tests/test_sample.py . [100%]

============================================================== warnings summary ===============================================================
tests/test_sample.py::test_counts
 /home/glue_user/spark/python/pyspark/sql/context.py:79: DeprecationWarning: Deprecated in 3.0.0. Use SparkSession.builder.getOrCreate() instead.
 DeprecationWarning)

-- Docs: https://docs.pytest.org/en/stable/warnings.html
======================================================== 1 passed, *1 warning* in 21.07s ========================================================

Jupyter Lab

Sie können Jupyter für die interaktive Entwicklung und Ad-hoc-Abfragen in Notebooks starten.

Führen Sie den folgenden Befehl aus, um Jupyter Lab zu starten:


$ JUPYTER_WORKSPACE_LOCATION=/local_path_to_workspace/jupyter_workspace/
$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $JUPYTER_WORKSPACE_LOCATION:/home/glue_user/workspace/jupyter_workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 -p 8998:8998 -p 8888:8888 --name glue_jupyter_lab amazon/aws-glue-libs:glue_libs_4.0.0_image_01 /home/glue_user/jupyter/jupyter_start.sh
...
[I 2022-01-24 08:19:21.368 ServerApp] Serving notebooks from local directory: /home/glue_user/workspace/jupyter_workspace
[I 2022-01-24 08:19:21.368 ServerApp] Jupyter Server 1.13.1 is running at:
[I 2022-01-24 08:19:21.368 ServerApp] http://faa541f8f99f:8888/lab
[I 2022-01-24 08:19:21.368 ServerApp] or http://127.0.0.1:8888/lab
[I 2022-01-24 08:19:21.368 ServerApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).

Öffnen Sie http://127.0.0.1:8888/lab in Ihrem Webbrowser auf Ihrem lokalen Computer, um die Jupyter-Lab-Benutzeroberfläche anzuzeigen.
Klicken Sie unter Notebook auf Glue Spark Local (PySpark). Sie können damit beginnen, in der interaktiven Jupyter-Notebook-Benutzeroberfläche Code zu entwickeln.

Einrichten des Containers für die Verwendung von Visual Studio Code

Voraussetzungen:

Installieren Sie Visual Studio Code.
Installieren Sie Python.
Installieren Sie Visual Studio Code Remote - Containers
Öffnen Sie den Workspace-Ordner in Visual Studio Code.
Wählen Sie Settings (Einstellungen) aus.
Wählen Sie Workspace aus.
Wählen Sie Open Settings (JSON) (Einstellungen öffnen (JSON)) aus.

Fügen Sie das folgende JSON ein und speichern Sie die Einstellung.


{
    "python.defaultInterpreterPath": "/usr/bin/python3",
    "python.analysis.extraPaths": [
        "/home/glue_user/aws-glue-libs/PyGlue.zip:/home/glue_user/spark/python/lib/py4j-0.10.9-src.zip:/home/glue_user/spark/python/",
    ]
}

Schritte:

Führen Sie den Docker-Container aus.


$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pyspark amazon/aws-glue-libs:glue_libs_4.0.0_image_01 pyspark

Starten Sie Visual Studio Code.
Wählen Sie im linken Menü Remote Explorer und dann amazon/aws-glue-libs:glue_libs_4.0.0_image_01 aus.
Klicken Sie mit der rechten Maustaste und wählen Sie Attach to Container (An Container anhängen) aus. Wenn ein Dialogfeld angezeigt wird, wählen Sie Got it (Verstanden) aus.
Öffnen Sie /home/glue_user/workspace/.
Erstellen Sie ein Glue-PySpark-Skript und wählen Sie Run (Ausführen) aus.

Sie werden die erfolgreiche Ausführung des Skripts sehen.

Anhang: AWS Glue-Auftragsbeispielcode für Testzwecke

Dieser Anhang enthält Skripts als AWS Glue-Auftragsbeispielcode für Testzwecke.

sample.py: Beispielcode zur Verwendung der AWS Glue-ETL-Bibliothek mit einem Amazon-S3-API-Aufruf


import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions


class GluePythonSampleTest:
    def __init__(self):
        params = []
        if '--JOB_NAME' in sys.argv:
            params.append('JOB_NAME')
        args = getResolvedOptions(sys.argv, params)

        self.context = GlueContext(SparkContext.getOrCreate())
        self.job = Job(self.context)

        if 'JOB_NAME' in args:
            jobname = args['JOB_NAME']
        else:
            jobname = "test"
        self.job.init(jobname, args)

    def run(self):
        dyf = read_json(self.context, "s3://awsglue-datasets/examples/us-legislators/all/persons.json")
        dyf.printSchema()

        self.job.commit()


def read_json(glue_context, path):
    dynamicframe = glue_context.create_dynamic_frame.from_options(
        connection_type='s3',
        connection_options={
            'paths': [path],
            'recurse': True
        },
        format='json'
    )
    return dynamicframe


if __name__ == '__main__':
    GluePythonSampleTest().run()

Für den obigen Code werden Amazon-S3-Berechtigungen in AWS IAM benötigt. Sie müssen die IAM-verwaltete Richtlinie arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess oder eine benutzerdefinierte IAM-Richtlinie, mit der Sie ListBucket und GetObject für den Amazon-S3-Pfad aufrufen können, gewähren.

test_sample.py: Beispielcode für den Komponententest von sample.py.


import pytest
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
import sys
from src import sample


@pytest.fixture(scope="module", autouse=True)
def glue_context():
    sys.argv.append('--JOB_NAME')
    sys.argv.append('test_count')

    args = getResolvedOptions(sys.argv, ['JOB_NAME'])
    context = GlueContext(SparkContext.getOrCreate())
    job = Job(context)
    job.init(args['JOB_NAME'], args)

    yield(context)

    job.commit()


def test_counts(glue_context):
    dyf = sample.read_json(glue_context, "s3://awsglue-datasets/examples/us-legislators/all/persons.json")
    assert dyf.toDF().count() == 1961

Entwickeln mit der AWS Glue-ETL-Bibliothek

Die AWS Glue-ETL-Bibliothek ist in einem öffentlichen Amazon-S3-Bucket verfügbar und kann vom Apache-Maven-Build-System genutzt werden. Auf diese Weise können Sie Ihre Python und Scala ETL-Skripts (Extrahieren, Transformieren und Laden) lokal entwickeln und testen, ohne dass eine Netzwerkverbindung erforderlich ist. Eine lokale Entwicklung mit dem Docker-Image wird empfohlen, da es eine Umgebung bietet, die für die Verwendung dieser Bibliothek ordnungsgemäß konfiguriert ist.

Die lokale Entwicklung ist für alle AWS Glue-Versionen, einschließlich AWS Glue Version 0.9, 1.0, 2.0 und höher verfügbar. Weitere Informationen zu den Versionen von Python und Apache Spark, die mit AWS Glue verfügbar sind, finden Sie unter Glue version job property.

Die Bibliothek wird mit der Amazon-Softwarelizenz (https://aws.amazon.com/asl) veröffentlicht.

Lokale Entwicklungseinschränkungen

Beachten Sie die folgenden Einschränkungen bei der Verwendung der AWS Glue Scala-Bibliothek zur lokalen Entwicklung.

Vermeiden Sie das Erstellen eines Assembly-JAR („fat jar“ oder „uber jar“) mit der AWS Glue-Bibliothek, da dies zur Deaktivierung der folgenden Features führt:
- Auftrags-Lesezeichen
- AWS Glue Parquet-Writer (Verwenden des Parquet-Formats in AWS-Glue)
- FillMissingValues-Transformation (Scala oder Python)
Diese Features sind nur innerhalb des AWS Glue-Auftragssystems verfügbar.
Die FindMatches-Transformation wird bei lokaler Entwicklung nicht unterstützt.
Der vektorisierte SIMD-CSV-Reader wird bei der lokalen Entwicklung nicht unterstützt.
Die Eigenschaft customJdbcDriverS3Path zum Laden des JDBC-Treibers vom S3-Pfad wird bei der lokalen Entwicklung nicht unterstützt. Alternativ können Sie den JDBC-Treiber lokal herunterladen und von dort laden.
Die Glue Data Quality wird bei der lokalen Entwicklung nicht unterstützt.

Lokale Entwicklung mit Python

Führen Sie einige erforderliche Schritte aus und verwenden Sie dann AWS Glue-Dienstprogramme, um Ihr Python ETL-Skript zu testen und abzusenden.

Voraussetzungen für die lokale Python-Entwicklung

Führen Sie die folgenden Schritte aus, um sich auf die lokale Python-Entwicklung vorzubereiten:

Klonen Sie das AWS Glue Python-Repository von GitHub (https://github.com/awslabs/aws-glue-libs).
Führen Sie eine der folgenden Aktionen aus:
- Für AWS Glue 0.9 verwenden Sie den Branch glue-0.9.
- Für AWS Glue 1.0 verwenden Sie den Branch glue-1.0. Alle Versionen ab AWS Glue 0.9 unterstützen Python 3.
- Für AWS Glue 2.0 verwenden Sie den Branch glue-2.0.
- Für AWS Glue-Version 3.0 verwenden Sie den Branch glue-3.0.
- Für AWS Glue-Version 4.0 verwenden Sie den Branch master.
Installieren Sie Apache Maven vom folgenden Speicherort: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.
Installieren Sie die Apache-Spark-Verteilung von den folgenden Speicherorten:
- Für AWS Glue Version 0.9: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-0.9/spark-2.2.1-bin-hadoop2.7.tgz
- Für AWS Glue Version 1.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-1.0/spark-2.4.3-bin-hadoop2.8.tgz
- Für AWS Glue Version 2.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-2.0/spark-2.4.3-bin-hadoop2.8.tgz
- Für AWS Glue Version 3.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-3.0/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3.tgz
- Für AWS Glue-Version 4.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-4.0/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0.tgz
Exportieren Sie die SPARK_HOME-Umgebungsvariable und setzen Sie sie auf den aus dem Spark-Archiv extrahierten Stammspeicherort. Zum Beispiel:
- Für AWS Glue Version 0.9: export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7
- Für AWS Glue Version 1.0 und 2.0: export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8
- Für AWS Glue Version 3.0: export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3
- Für AWS Glue-Version 4.0: export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Ausführen Ihres Python ETL-Skripts

Mit den AWS Glue-JAR-Dateien, die für die lokale Entwicklung verfügbar sind, können Sie das AWS Glue Python-Paket lokal ausführen.

Verwenden Sie die folgenden Dienstprogramme und Frameworks, um Ihr Python-Skript zu testen und auszuführen. Die in der folgenden Tabelle aufgeführten Befehle werden aus dem Stammverzeichnis des AWS Glue Python-Pakets ausgeführt.

Dienstprogramm	Befehl	Beschreibung
AWS Glue-Shell	`./bin/gluepyspark`	Geben Sie Python-Skripts in einer Shell ein, die in AWS Glue ETL-Bibliotheken integriert ist, und führen Sie sie aus.
AWS Glue Absenden	`./bin/gluesparksubmit`	Senden Sie ein vollständiges Python-Skript zur Ausführung.
Pytest	`./bin/gluepytest`	Schreiben und führen Sie Einheitentests Ihres Python-Codes aus. Das pytest-Modul muss installiert und im `PATH` verfügbar sein. Weitere Informationen finden Sie in der pytest-Dokumentation.

Lokale Entwicklung mit Scala

Führen Sie einige erforderliche Schritte aus und geben Sie dann einen Maven-Befehl aus, um Ihr Scala ETL-Skript lokal auszuführen.

Voraussetzungen für die lokale Scala-Entwicklung

Führen Sie die folgenden Schritte aus, um die lokale Scala-Entwicklung vorzubereiten.

Schritt 1: Installieren der Software

In diesem Schritt installieren Sie Software und legen die erforderliche Umgebungsvariable fest.

Installieren Sie Apache Maven vom folgenden Speicherort: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.
Installieren Sie die Apache-Spark-Verteilung von den folgenden Speicherorten:
- Für AWS Glue Version 0.9: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-0.9/spark-2.2.1-bin-hadoop2.7.tgz
- Für AWS Glue Version 1.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-1.0/spark-2.4.3-bin-hadoop2.8.tgz
- Für AWS Glue Version 2.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-2.0/spark-2.4.3-bin-hadoop2.8.tgz
- Für AWS Glue Version 3.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-3.0/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3.tgz
- Für AWS Glue-Version 4.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-4.0/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0.tgz
Exportieren Sie die SPARK_HOME-Umgebungsvariable und setzen Sie sie auf den aus dem Spark-Archiv extrahierten Stammspeicherort. Zum Beispiel:
- Für AWS Glue Version 0.9: export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7
- Für AWS Glue Version 1.0 und 2.0: export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8
- Für AWS Glue Version 3.0: export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3
- Für AWS Glue-Version 4.0: export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Schritt 2: Konfigurieren des Maven-Projekts

Verwenden Sie die folgende pom.xml-Datei als Vorlage für Ihre AWS Glue Scala-Anwendungen. Sie enthält die erforderlichen plugins-, dependencies- und repositories-Elemente. Ersetzen Sie die Glue version Zeichenfolge durch einen der folgenden Werte:

4.0.0 für AWS Glue-Version 4.0
3.0.0 für AWS Glue Version 3.0
1.0.0 für AWS Glue Version 1.0 oder 2.0
0.9.0 für AWS Glue Version 0.9


  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.amazonaws</groupId>
    <artifactId>AWSGlueApp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>${project.artifactId}</name>
    <description>AWS ETL application</description>

        <properties>
            <scala.version>2.11.1 for AWS Glue 2.0 or below, 2.12.7 for AWS Glue 3.0 and 4.0</scala.version>
            <glue.version>Glue version with three numbers (as mentioned earlier)</glue.version>
        </properties>
    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
			<!-- A "provided" dependency, this will be ignored when you package your application -->
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>AWSGlueETL</artifactId>
			<version>${glue.version}</version>
            <!-- A "provided" dependency, this will be ignored when you package your application -->
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <repositories>
        <repository>
            <id>aws-glue-etl-artifacts</id>
            <url>https://aws-glue-etl-artifacts.s3.amazonaws.com/release/</url>
        </repository>
    </repositories>
    <build>
        <sourceDirectory>src/main/scala</sourceDirectory>
        <plugins>
            <plugin>
                <!-- see http://davidb.github.com/scala-maven-plugin -->
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.4.0</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.6.0</version>
                <executions>
                    <execution>
                        <goals>
                        <goal>java</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                <systemProperties>
                    <systemProperty>
                        <key>spark.master</key>
                        <value>local[*]</value>
                    </systemProperty>
                    <systemProperty>
                        <key>spark.app.name</key>
                        <value>localrun</value>
                    </systemProperty>
                    <systemProperty>
                        <key>org.xerial.snappy.lib.name</key>
                        <value>libsnappyjava.jnilib</value>
                    </systemProperty>
                </systemProperties>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <version>3.0.0-M2</version>
                <executions>
                    <execution>
                        <id>enforce-maven</id>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <requireMavenVersion>
                                    <version>3.5.3</version>
                                </requireMavenVersion>
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
			<!-- The shade plugin will be helpful in building a uberjar or fatjar.
			You can use this jar in the AWS Glue runtime environment. For more information, see https://maven.apache.org/plugins/maven-shade-plugin/ -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <configuration>
                    <!-- any other shade configurations -->
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Ausführen Ihres Scala ETL-Skripts

Führen Sie im Stammverzeichnis des Maven-Projekts den folgenden Befehl aus, um das Scala-ETL-Skript auszuführen.


mvn exec:java -Dexec.mainClass="mainClass" -Dexec.args="--JOB-NAME jobName"

Ersetzen Sie mainClass durch den vollständig qualifizierten Klassennamen der Hauptklasse des Skripts. Ersetzen Sie jobName durch den gewünschten Auftragsnamen.

Konfigurieren einer Testumgebung

Beispiele für die Konfiguration einer lokalen Testumgebung finden Sie in den folgenden Blogbeiträgen:

Wenn Sie Entwicklungsendpunkte oder Notebooks zum Testen Ihrer ETL-Skripte verwenden möchten, finden Sie hier weitere Informationen: Entwickeln von Skripts unter Verwendung von Entwicklungsendpunkten.

Anmerkung

Entwicklungsendpunkte werden nicht für die Verwendung mit Aufträgen von AWS Glue Version 2.0 unterstützt. Weitere Informationen finden Sie unter Ausführen von Spark-ETL-Aufträgen mit verkürzten Startupzeiten.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Arbeiten mit Streaming-Vorgängen in AWS Glue interaktiven Sitzungen

Entwicklungsendpunkte