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: Ein AWS Glue for Spark-Skript schreiben
Dieses Tutorial führt Sie in den Prozess des Schreibens von AWS Glue-Skripten ein. Sie können Skripte nach einem Zeitplan mit Aufträgen oder interaktiv mit interaktiven Sitzungen ausführen. Weitere Informationen über Aufträge finden Sie unter [Erstellen von Visual-ETL-Aufträgen](author-job-glue.md). Weitere Informationen zu interaktiven Sitzungen finden Sie unter [Überblick über AWS Glue-interaktive Sitzungen](interactive-sessions-chapter.md#interactive-sessions-overview).
Der visuelle Editor von AWS Glue Studio bietet eine grafische Oberfläche ohne Code für die Erstellung von AWS Glue-Jobs. AWS Glue Sie Skripte auf visuelle Jobs zurück. Sie bieten Ihnen Zugriff auf die erweiterten Tools, die für die Arbeit mit Apache-Spark-Programmen zur Verfügung stehen. Sie können von einem Glue-Skript aus auf native Spark APIs - und AWS Glue-Bibliotheken zugreifen, die Workflows zum Extrahieren, Transformieren und Laden (ETL) erleichtern. AWS
In diesem Tutorial extrahieren, transformieren und laden Sie einen Datensatz mit Parktickets. Das Skript, das diese Arbeit erledigt, ist in Form und Funktion identisch mit dem Skript, das in [Making ETL easier with AWS Glue Studio](https://aws.amazon.com/blogs/big-data/making-etl-easier-with-aws-glue-studio/) auf dem AWS Big Data Blog generiert wurde, in dem der visuelle Editor von AWS Glue Studio vorgestellt wird. Wenn Sie dieses Skript in einem Job ausführen, können Sie es mit visuellen Jobs vergleichen und sehen, wie AWS Glue-ETL-Skripts funktionieren. Dies bereitet Sie darauf vor, zusätzliche Funktionen zu verwenden, die in visuellen Aufträgen noch nicht verfügbar sind.
In diesem Tutorial verwenden Sie die Sprache Python und die Bibliotheken. Eine ähnliche Funktionalität ist in Scala verfügbar. Nachdem Sie dieses Tutorial durchgearbeitet haben, sollten Sie in der Lage sein, ein Scala-Beispielskript zu generieren und zu überprüfen, um zu verstehen, wie der Scala AWS Glue-ETL-Skriptschreibprozess durchgeführt wird.
## Voraussetzungen
Für dieses Tutorial müssen die folgenden Voraussetzungen erfüllt sein:
+ Dieselben Voraussetzungen wie im AWS Glue Studio-Blogbeitrag, in dem Sie aufgefordert werden, eine CloudFormation Vorlage auszuführen.
Diese Vorlage verwendet den AWS Glue-Datenkatalog, um den in verfügbaren Parkscheindatensatz zu verwalten`s3://aws-bigdata-blog/artifacts/gluestudio/`. Sie erstellt die folgenden Ressourcen, auf die verwiesen wird:
+ **AWS Glue StudioRole** (Rolle) – IAM-Rolle zum Ausführen von AWS Glue-Aufträgen
+ **AWS Glue StudioAmazon S3Bucket** – Name des Amazon-S3-Buckets zum Speichern von blogbezogenen Dateien
+ **AWS Glue StudioTicketsyyzDB** – AWS Glue Datenkatalog-Datenbank
+ **AWS Glue StudioTableTickets**— Datenkatalogtabelle, die als Quelle verwendet werden soll
+ **AWS Glue StudioTableTrials**— Datenkatalogtabelle, die als Quelle verwendet werden soll
+ **AWS Glue StudioParkingTicketCount **— Datenkatalogtabelle, die als Ziel verwendet werden soll
+ Das im AWS Glue Studio-Blogbeitrag generierte Skript. Falls sich der Blogbeitrag ändert, finden Sie das Skript auch im folgenden Text.
### Generieren eines Beispielskripts
Sie können den Visual Editor von AWS Glue Studio als leistungsstarkes Tool zur Codegenerierung verwenden, um ein Gerüst für das Skript zu erstellen, das Sie schreiben möchten. Mit diesem Tool erstellen Sie ein Beispielskript.
Wenn Sie diese Schritte überspringen möchten, wird das Skript bereitgestellt.
#### Tutorial-Beispielskript
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args["JOB_NAME"], args)
# Script generated for node S3 bucket
S3bucket_node1 = glueContext.create_dynamic_frame.from_catalog(
database="yyz-tickets", table_name="tickets", transformation_ctx="S3bucket_node1"
)
# Script generated for node ApplyMapping
ApplyMapping_node2 = ApplyMapping.apply(
frame=S3bucket_node1,
mappings=[
("tag_number_masked", "string", "tag_number_masked", "string"),
("date_of_infraction", "string", "date_of_infraction", "string"),
("ticket_date", "string", "ticket_date", "string"),
("ticket_number", "decimal", "ticket_number", "float"),
("officer", "decimal", "officer_name", "decimal"),
("infraction_code", "decimal", "infraction_code", "decimal"),
("infraction_description", "string", "infraction_description", "string"),
("set_fine_amount", "decimal", "set_fine_amount", "float"),
("time_of_infraction", "decimal", "time_of_infraction", "decimal"),
],
transformation_ctx="ApplyMapping_node2",
)
# Script generated for node S3 bucket
S3bucket_node3 = glueContext.write_dynamic_frame.from_options(
frame=ApplyMapping_node2,
connection_type="s3",
format="glueparquet",
connection_options={"path": "s3://DOC-EXAMPLE-BUCKET", "partitionKeys": []},
format_options={"compression": "gzip"},
transformation_ctx="S3bucket_node3",
)
job.commit()
```
**So generieren Sie ein Beispielskript**
1. Schließe das AWS Glue Studio-Tutorial ab. Um dieses Tutorial abzuschließen, siehe [Einen Job in AWS Glue Studio anhand eines Beispieljobs](https://docs.aws.amazon.com/glue/latest/dg/edit-nodes-chapter.html#create-jobs-start.html) erstellen.
1. Navigieren Sie auf der Auftragsseite zur Registerkarte **Script** (Skript), wie im folgenden Screenshot gezeigt:
![\[Die Registerkarte „Skript“ für einen AWS Glue-Job.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/programming-intro-generated-script.png)
1. Kopieren Sie den vollständigen Inhalt der Registerkarte **Script** (Skript). Durch Einstellen der Skriptsprache in **Job details** (Auftragsdetails) können Sie zwischen der Generierung von Python- oder Scala-Code hin und her wechseln.
## Schritt 1. Erstellen eines Auftrags und Einfügen Ihres Skripts
In diesem Schritt erstellen Sie einen AWS Glue-Job in der AWS-Managementkonsole. Dadurch wird eine Konfiguration eingerichtet, die es AWS Glue ermöglicht, Ihr Skript auszuführen. Es schafft auch einen Ort, an dem Sie Ihr Skript speichern und bearbeiten können.
**So erstellen Sie einen --Auftrag**
1. Navigieren Sie in der AWS-Managementkonsole zur AWS Glue-Landingpage.
1. Wählen Sie im seitlichen Navigationsbereich **Jobs** (Aufträge) aus.
1. Wählen Sie **Spark script editor** (Spark-Skript-Editor) in **Create job** (Auftrag erstellen) und wählen Sie dann **Create** (Erstellen) aus.
1. **Optional** – Fügen Sie den vollständigen Text Ihres Skripts in den Bereich **Script** (Skript) ein. Alternativ können Sie dem Tutorial folgen.
## Schritt 2. AWS Glue-Bibliotheken importieren
Sie müssen Ihr Skript so einrichten, dass es mit Code und Konfiguration interagiert, die außerhalb des Skripts definiert sind. Diese Arbeit wird hinter den Kulissen von AWS Glue Studio erledigt.
In diesem Schritt führen Sie die folgenden Aktionen durch.
+ Importieren und initialisieren Sie ein `GlueContext`-Objekt. Dies ist beim Schreiben von Skripten der wichtigste Import. Dadurch werden Standardmethoden zum Definieren von Quell- und Zieldatensätzen verfügbar, die der Ausgangspunkt für jedes ETL-Skript sind. Weitere Informationen zur `GlueContext`-Klasse finden Sie unter [GlueContext Klasse](aws-glue-api-crawler-pyspark-extensions-glue-context.md).
+ Initialisieren Sie `SparkContext` und `SparkSession`. Diese ermöglichen es Ihnen, die Spark-Engine zu konfigurieren, die im AWS Glue-Job verfügbar ist. Sie müssen sie nicht direkt in einführenden AWS Glue-Skripten verwenden.
+ Rufen Sie `getResolvedOptions` auf, um Ihre Auftragsargumente für die Verwendung innerhalb des Skripts vorzubereiten. Weitere Informationen zum Auflösen von Auftragsparametern finden Sie unter [Zugriff auf Parameter mit `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md).
+ Initialisieren eines `Job`. Das `Job` Objekt legt die Konfiguration fest und verfolgt den Status verschiedener optionaler AWS Glue-Funktionen. Ihr Skript kann ohne ein `Job`-Objekt ausgeführt werden, aber die beste Vorgehensweise ist, es zu initialisieren. So kommt es später nicht zu Verwirrungen, wenn diese Features später integriert werden.
Eine dieser Features sind Auftragslesezeichen, die Sie in diesem Tutorial optional konfigurieren können. Im folgenden Abschnitt [Optional – Auftragslesezeichen aktivieren](#aws-glue-programming-intro-tutorial-create-job-bookmarks) erfahren Sie mehr über Auftragslesezeichen.
In diesem Verfahren schreiben Sie den folgenden Code. Dieser Code ist ein Teil des generierten Beispielskripts.
```
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args["JOB_NAME"], args)
```
**Um AWS Glue-Bibliotheken zu importieren**
+ Kopieren Sie diesen Codeabschnitt und fügen Sie ihn in den **Script** (Skript)-Editor ein.
**Anmerkung**
Sie sollten bedenken, dass das Kopieren von Code eine schlechte technische Praxis ist. In diesem Tutorial empfehlen wir dies, um Sie zu ermutigen, Ihre Kernvariablen in allen AWS Glue-ETL-Skripten einheitlich zu benennen.
## Schritt 3. Extrahieren von Daten aus einer Quelle
Bei jedem ETL-Prozess müssen Sie zunächst einen Quelldatensatz definieren, den Sie ändern möchten. Im visuellen Editor von AWS Glue Studio stellen Sie diese Informationen bereit, indem Sie einen **Quellknoten** erstellen.
In diesem Schritt geben Sie für die `create_dynamic_frame.from_catalog`-Methode eine `database` und einen `table_name` an, um Daten aus einer Quelle zu extrahieren, die im AWS -Glue-Datenkatalog konfiguriert wurden.
Im vorherigen Schritt haben Sie ein `GlueContext`-Objekt initialisiert. Sie verwenden dieses Objekt, um Methoden zu finden, die zum Konfigurieren von Quellen verwendet werden, z. B `create_dynamic_frame.from_catalog`.
In diesem Verfahren schreiben Sie den folgenden Code mithilfe von `create_dynamic_frame.from_catalog`. Dieser Code ist ein Teil des generierten Beispielskripts.
```
S3bucket_node1 = glueContext.create_dynamic_frame.from_catalog(
database="yyz-tickets", table_name="tickets", transformation_ctx="S3bucket_node1"
)
```
**So extrahieren Sie Daten aus einer Quelle**
1. Suchen Sie in der Dokumentation nach einer Methode `GlueContext` zum Extrahieren von Daten aus einer im AWS Glue-Datenkatalog definierten Quelle. Diese Methoden sind dokumentiert in [GlueContext Klasse](aws-glue-api-crawler-pyspark-extensions-glue-context.md). Wählen Sie die Methode [create\$1dynamic\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog). Rufen Sie diese Methode auf `glueContext` auf.
1. Untersuchen Sie die Dokumentation auf `create_dynamic_frame.from_catalog`. Diese Methode erfordert die Parameter `database` und `table_name`. Stellen Sie die notwendigen Parameter für `create_dynamic_frame.from_catalog` bereit.
Der AWS Glue-Datenkatalog speichert Informationen über den Speicherort und das Format Ihrer Quelldaten und wurde im Abschnitt mit den Voraussetzungen eingerichtet. Sie müssen diese Informationen nicht direkt in Ihr Skript eingeben.
1. **Optional** – Stellen Sie die `transformation_ctx`-Parameter der Methode bereit, um Auftragslesezeichen zu unterstützen. Im folgenden Abschnitt [Optional – Auftragslesezeichen aktivieren](#aws-glue-programming-intro-tutorial-create-job-bookmarks) erfahren Sie mehr über Auftragslesezeichen.
**Anmerkung**
**Gängige Methoden zum Extrahieren von Daten**
[create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog)wird verwendet, um eine Verbindung zu Tabellen im AWS Glue-Datenkatalog herzustellen.
Wenn Sie Ihren Auftrag direkt mit einer Konfiguration versehen müssen, die die Struktur und den Standort Ihrer Quelle beschreibt, sehen Sie sich die Methode [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) an. Sie müssen detailliertere Parameter zur Beschreibung Ihrer Daten angeben als bei `create_dynamic_frame.from_catalog`.
Weitere Informationen zur Identifikation der erforderlichen Parameter finden Sie in der zusätzlichen Dokumentation zu `format_options` und `connection_parameters`. Eine Erläuterung, wie Sie Ihre Skriptinformationen zu Ihrem Quelldatenformat bereitstellen, finden Sie unter [Mögliche Formate für Eingaben und Ausgaben in AWS Glue für Spark](aws-glue-programming-etl-format.md). Eine Erläuterung, wie Sie Ihre Skriptinformationen zu Ihrem Quelldatenstandort bereitstellen, finden Sie unter [Verbindungstypen und Optionen für ETL in AWS Glue für Spark](aws-glue-programming-etl-connect.md).
Wenn Sie Informationen aus einer Streaming-Quelle lesen, stellen Sie Ihrem Auftrag Quellinformationen über die Methoden [create\$1data\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog) oder [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) bereit. Beachten Sie, dass diese Methoden Apache-Spark-`DataFrames` zurückgeben.
Unser generierter Code ruft `create_dynamic_frame.from_catalog` auf, während sich die Referenzdokumentation auf `create_dynamic_frame_from_catalog` bezieht. Diese Methoden rufen letztendlich denselben Code auf und sind enthalten, sodass Sie saubereren Code schreiben können. Sie können dies überprüfen, indem Sie sich den Quellcode für unseren Python-Wrapper ansehen, der unter [https://github.com/awslabs/aws-glue-libs/blob/master/awsglue/context.py](https://github.com/awslabs/aws-glue-libs/blob/master/awsglue/context.py) verfügbar ist.
## Schritt 4. Daten mit AWS Glue transformieren
Nach dem Extrahieren der Quelldaten in einem ETL-Prozess müssen Sie beschreiben, wie Sie Ihre Daten ändern möchten. Sie stellen diese Informationen bereit, indem Sie im visuellen Editor von AWS Glue Studio einen **Transform-Knoten** erstellen.
In diesem Schritt stellen Sie der `ApplyMapping`-Methode eine Karte mit aktuellen und gewünschten Feldnamen und -typen zur Transformation Ihres `DynamicFrame` bereit.
Führen Sie die folgenden Transformationen aus.
+ Löschen Sie die vier `location`- und `province`-Schlüssel.
+ Ändern Sie den Namen von `officer` zu `officer_name`.
+ Ändern Sie den Typ von `ticket_number` und `set_fine_amount` zu `float`.
`create_dynamic_frame.from_catalog` bietet Ihnen ein `DynamicFrame`-Objekt. A `DynamicFrame` steht für einen Datensatz in AWS Glue. AWS Klebetransformationen sind Operationen, die sich ändern`DynamicFrames`.
**Anmerkung**
Was ist ein `DynamicFrame`?
Ein `DynamicFrame` ist eine Abstraktion, mit der Sie einen Datensatz mit einer Beschreibung der Namen und Typen von Einträgen in den Daten verbinden können. In Apache Spark gibt es eine ähnliche Abstraktion, die als a bezeichnet wird. DataFrame Eine Erklärung von DataFrames finden Sie im [Spark SQL Guide](https://spark.apache.org/docs/latest/sql-programming-guide.html).
Mit `DynamicFrames` können Sie Datensatzschemata dynamisch beschreiben. Stellen Sie sich einen Datensatz mit einer Preisspalte vor, in der einige Einträge den Preis als Zeichenfolge und andere den Preis als Doppelzahl speichern. AWS Glue berechnet ein Schema on-the-fly — es erstellt für jede Zeile einen sich selbst beschreibenden Datensatz.
Inkonsistente Felder (wie Preis) werden explizit mit einem Typ dargestellt (`ChoiceType`) im Schema für den Rahmen. Sie können Ihre inkonsistenten Felder beheben, indem Sie sie mit `DropFields` löschen oder mit `ResolveChoice` auflösen. Dies sind Transformationen, die auf dem `DynamicFrame` verfügbar sind. Sie können Ihre Daten dann mit `writeDynamicFrame` zurück in Ihren Data Lake schreiben.
Sie können viele der gleichen Transformationen über Methoden in der `DynamicFrame`-Klasse abrufen, was zu besser lesbaren Skripten führen kann. Mehr über `DynamicFrame` erfahren Sie unter [DynamicFrame Klasse](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md).
In diesem Verfahren schreiben Sie den folgenden Code mithilfe von `ApplyMapping`. Dieser Code ist ein Teil des generierten Beispielskripts.
```
ApplyMapping_node2 = ApplyMapping.apply(
frame=S3bucket_node1,
mappings=[
("tag_number_masked", "string", "tag_number_masked", "string"),
("date_of_infraction", "string", "date_of_infraction", "string"),
("ticket_date", "string", "ticket_date", "string"),
("ticket_number", "decimal", "ticket_number", "float"),
("officer", "decimal", "officer_name", "decimal"),
("infraction_code", "decimal", "infraction_code", "decimal"),
("infraction_description", "string", "infraction_description", "string"),
("set_fine_amount", "decimal", "set_fine_amount", "float"),
("time_of_infraction", "decimal", "time_of_infraction", "decimal"),
],
transformation_ctx="ApplyMapping_node2",
)
```
**Um Daten mit AWS Glue zu transformieren**
1. Sehen Sie sich die Dokumentation an, um eine Transformation zum Ändern und Löschen von Feldern zu identifizieren. Details hierzu finden Sie unter [GlueTransform Basisklasse](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md). Wählen Sie die Transformation `ApplyMapping` aus. Mehr über `ApplyMapping` erfahren Sie unter [ApplyMapping Klasse](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md). Rufen Sie `apply` über das Transformationsobjekt `ApplyMapping` auf.
**Anmerkung**
Was ist `ApplyMapping`?
`ApplyMapping` nimmt einen `DynamicFrame` und transformiert ihn. Es braucht eine Liste von Tupeln, die Transformationen auf Feldern darstellen – eine „Zuordnung“. Die ersten beiden Tupelelemente, ein Feldname und ein Typ, werden verwendet, um ein Feld im Rahmen zu identifizieren. Die zweiten beiden Parameter sind ebenfalls ein Feldname und ein Feldtyp.
ApplyMapping konvertiert das Quellfeld in den Zielnamen und gibt einen neuen ein`DynamicFrame`, den es zurückgibt. Nicht bereitgestellte Felder werden im Rückgabewert gelöscht.
Statt `apply` aufzurufen, können Sie dieselbe Transform mit der `apply_mapping`-Methode im `DynamicFrame` aufrufen, um fließenderen, lesbareren Code zu erstellen. Weitere Informationen finden Sie unter [apply\$1mapping](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-apply_mapping).
1. Sehen Sie sich die Dokumentation zu `ApplyMapping` an, um erforderliche Parameter zu identifizieren. Siehe [ApplyMapping Klasse](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md). Sie werden feststellen, dass diese Methode die Parameter `frame` und `mappings` erfordert. Stellen Sie die notwendigen Parameter für `ApplyMapping` bereit.
1. **Optional** – Stellen Sie der Methode `transformation_ctx` bereit, um Auftragslesezeichen zu unterstützen. Im folgenden Abschnitt [Optional – Auftragslesezeichen aktivieren](#aws-glue-programming-intro-tutorial-create-job-bookmarks) erfahren Sie mehr über Auftragslesezeichen.
**Anmerkung**
**Apache-Spark-Funktion**
Wir bieten Transformationen, um ETL-Workflows in Ihrem Auftrag zu optimieren. Sie haben auch Zugriff auf die Bibliotheken, die in einem Spark-Programm in Ihrem Auftrag verfügbar sind, das für allgemeinere Zwecke entwickelt wurde. Um diese zu verwenden, konvertieren Sie zwischen `DynamicFrame` und `DataFrame`.
Sie können einen `DataFrame` mit [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) erstellen. Anschließend können Sie die auf der Website verfügbaren Methoden verwenden DataFrame , um Ihren Datensatz zu transformieren. Weitere Informationen zu diesen Methoden finden Sie unter [DataFrame](https://spark.apache.org/docs/3.1.1/api/python/reference/api/pyspark.sql.DataFrame.html). Sie können dann rückwärts konvertieren[fromDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-fromDF), um Ihren Frame mithilfe von AWS Glue-Operationen auf ein Ziel zu laden.
## Schritt 5. Daten in ein Ziel laden
Nachdem Sie Ihre Daten transformiert haben, speichern Sie die transformierten Daten in der Regel an einem anderen Ort als der Quelle. Sie führen diesen Vorgang durch, indem Sie im Visual Editor von AWS Glue Studio einen **Zielknoten** erstellen.
In diesem Schritt stellen Sie der `write_dynamic_frame.from_options`-Methode ein `connection_type`, `connection_options`, `format` und `format_options` bereit, um Daten in ein Ziel-Bucket in Amazon S3 zu laden.
Im ersten Schritt haben Sie ein `GlueContext`-Objekt initialisiert. In AWS Glue finden Sie hier Methoden, die zur Konfiguration von Zielen verwendet werden, ähnlich wie Quellen.
In diesem Verfahren schreiben Sie den folgenden Code mithilfe von `write_dynamic_frame.from_options`. Dieser Code ist ein Teil des generierten Beispielskripts.
```
S3bucket_node3 = glueContext.write_dynamic_frame.from_options(
frame=ApplyMapping_node2,
connection_type="s3",
format="glueparquet",
connection_options={"path": "s3://amzn-s3-demo-bucket", "partitionKeys": []},
format_options={"compression": "gzip"},
transformation_ctx="S3bucket_node3",
)
```
**So laden Sie Daten in ein Ziel**
1. Überprüfen Sie die Dokumentation, um eine Methode zum Laden von Daten in einen Ziel-Bucket von Amazon S3 zu finden. Diese Methoden sind dokumentiert in [GlueContext Klasse](aws-glue-api-crawler-pyspark-extensions-glue-context.md). Wählen Sie die [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options)-Methode. Rufen Sie diese Methode auf `glueContext` auf.
**Anmerkung**
**Gängige Methoden für das Laden von Daten**
`write_dynamic_frame.from_options` ist die gängigste Methode zum Laden von Daten. Es unterstützt alle Ziele, die in AWS Glue verfügbar sind.
Wenn Sie in ein JDBC-Ziel schreiben, das in einer AWS Glue-Verbindung definiert ist, verwenden Sie die [write\$1dynamic\$1frame\$1from\$1jdbc\$1conf](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_jdbc_conf) Methode. AWS In Klebeverbindungen werden Informationen darüber gespeichert, wie eine Verbindung zu einer Datenquelle hergestellt wird. Dadurch entfällt die Notwendigkeit, diese Informationen in `connection_options` bereitzustellen. Sie müssen jedoch immer noch `connection_options` verwenden, um `dbtable` bereitzustellen.
`write_dynamic_frame.from_catalog` ist keine gängige Methode zum Laden von Daten. Diese Methode aktualisiert den AWS Glue-Datenkatalog, ohne den zugrunde liegenden Datensatz zu aktualisieren, und wird in Kombination mit anderen Prozessen verwendet, die den zugrunde liegenden Datensatz ändern. Weitere Informationen finden Sie unter [Aktualisieren des Schemas und Hinzufügen neuer Partitionen im Datenkatalog mit AWS Glue-ETL-Aufträgen](update-from-job.md).
1. Untersuchen Sie die Dokumentation auf [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). Diese Methode erfordert `frame`, `connection_type`, `format`, `connection_options` und `format_options`. Rufen Sie diese Methode auf `glueContext` auf.
1. Weitere Informationen zu den erforderlichen Parametern finden Sie in der zusätzlichen Dokumentation zu `format_options` und `format`. Eine Erläuterung der Datenformate finden Sie unter [Mögliche Formate für Eingaben und Ausgaben in AWS Glue für Spark](aws-glue-programming-etl-format.md).
1. Weitere Informationen zu den erforderlichen Parametern finden Sie in der zusätzlichen Dokumentation zu `connection_type` und `connection_options`. Eine Erläuterung der Zusammenhänge finden Sie unter [Verbindungstypen und Optionen für ETL in AWS Glue für Spark](aws-glue-programming-etl-connect.md).
1. Stellen Sie die notwendigen Parameter für `write_dynamic_frame.from_options` bereit. Diese Methode hat eine ähnliche Konfiguration wie `create_dynamic_frame.from_options`.
1. **Optional** – Stellen Sie `transformation_ctx` für `write_dynamic_frame.from_options` bereit, um Auftragslesezeichen zu unterstützen. Im folgenden Abschnitt [Optional – Auftragslesezeichen aktivieren](#aws-glue-programming-intro-tutorial-create-job-bookmarks) erfahren Sie mehr über Auftragslesezeichen.
## Schritt 6: Bestätigen des `Job`-Objekts
In Schritt 1 haben Sie ein `Job`-Objekt initialisiert. Sie müssen den Lebenszyklus am Ende Ihres Skripts möglicherweise manuell abschließen, wenn dies für bestimmte optionale Funktionen erforderlich ist, um damit sie ordnungsgemäß funktionieren, z. B. bei der Verwendung von Auftragslesezeichen. Diese Arbeit wird hinter den Kulissen von AWS Glue Studio erledigt.
Rufen Sie in diesem Schritt die `commit`-Methode für das `Job`-Objekt auf.
In diesem Verfahren schreiben Sie den folgenden Code. Dieser Code ist ein Teil des generierten Beispielskripts.
```
job.commit()
```
**So bestätigen Sie das `Job`-Objekt**
1. Wenn Sie dies noch nicht getan haben, führen Sie die optionalen Schritte aus, die in den vorherigen Abschnitten beschrieben wurden, um `transformation_ctx` einzubeziehen.
1. Rufen Sie die Seite `commit` auf.
## Optional – Auftragslesezeichen aktivieren
In jedem vorherigen Schritt wurden Sie angewiesen, `transformation_ctx`-Parameter einzurichten. Dies bezieht sich auf ein Feature namens Auftragslesezeichen.
Mit Auftragslesezeichen können Sie bei Aufträgen, die auf wiederkehrender Basis ausgeführt werden, Zeit und Geld sparen, indem Sie auf Datensätze zugreifen, bei denen frühere Arbeiten leicht nachverfolgt werden können. Job-Lesezeichen verfolgen den Fortschritt einer AWS Glue-Transformation in einem Datensatz aus früheren Durchläufen. Indem AWS Glue nachverfolgt, wo frühere Läufe geendet haben, kann es seine Arbeit auf Zeilen beschränken, die es zuvor nicht verarbeitet hat. Weitere Informationen zu Auftragslesezeichen finden Sie unter [Verfolgen von verarbeiteten Daten mit Auftragslesezeichen](monitor-continuations.md).
Um Auftragslesezeichen zu aktivieren, fügen Sie zunächst die `transformation_ctx`-Anweisungen in unsere bereitgestellten Funktionen ein, wie in den vorherigen Beispielen beschrieben. Der Status des Auftragslesezeichens wird über mehrere Ausführungen hinweg beibehalten. `transformation_ctx`-Parameter sind Schlüssel, die für den Zugriff auf diesen Status verwendet werden. Für sich genommen werden diese Aussagen nichts bewirken. Sie müssen das Feature auch in der Konfiguration für Ihren Auftrag aktivieren.
In diesem Verfahren aktivieren Sie Auftragslesezeichen mit dem AWS-Managementkonsole.
**So aktivieren Sie Auftragslesezeichen**
1. Navigieren Sie zum Abschnitt **Job details** (Auftragsdetails) Ihres entsprechenden Auftrags.
1. Legen Sie für **Job bookmark** (Auftragslesezeichen) **Enable** (Aktivieren) fest.
## Schritt 7. Ausführen Ihres Codes als Auftrag
In diesem Schritt führen Sie Ihren Auftrag aus, um zu überprüfen, ob Sie dieses Tutorial erfolgreich abgeschlossen haben. Dies erfolgt mit einem Klick auf eine Schaltfläche, wie im visuellen Editor von AWS Glue Studio.
**So führen Sie Ihren Code als Auftrag aus**
1. Wählen Sie in der Titelleiste **Untitled Job** (Auftrag ohne Titel) aus, um Ihren Auftragsnamen zu bearbeiten und festzulegen.
1. Navigieren Sie zur Registerkarte **Job details** (Auftragsdetails). Weisen Sie Ihrem Auftrag eine **IAM-Rolle** zu. Sie können die mit der CloudFormation Vorlage erstellte Datei in den Voraussetzungen für das AWS Glue Studio-Tutorial verwenden. Wenn Sie dieses Tutorial abgeschlossen haben, sollte es verfügbar sein als `AWS Glue StudioRole`.
1. Wählen Sie **Save** (Speichern), um Ihr Skript zu speichern.
1. Wählen Sie **Run** (Ausführen) aus, um Ihren Auftrag auszuführen.
1. Navigieren Sie zur Registerkarte **Runs** (Ausführungen), um zu überprüfen, ob Ihr Auftrag abgeschlossen ist.
1. Navigieren Sie zu*amzn-s3-demo-bucket*, dem Ziel für`write_dynamic_frame.from_options`. Bestätigen Sie, dass die Ausgabe Ihren Erwartungen entspricht.
Weitere Informationen zum Konfigurieren und Verwalten von Aufträgen finden Sie unter [Bereitstellen eigener, benutzerdefinierter Skripts](console-custom-created.md).
## Weitere Informationen
Apache Spark-Bibliotheken und -Methoden sind in AWS Glue-Skripten verfügbar. Sie können sich die Spark-Dokumentation ansehen, um zu verstehen, was Sie mit diesen enthaltenen Bibliotheken tun können. Weitere Informationen finden Sie im [Abschnitt über Beispiele des Spark-Quell-Repositorys](https://github.com/apache/spark/tree/master/examples/src/main/python).
AWS Glue 2.0\$1 enthält standardmäßig mehrere gängige Python-Bibliotheken. Es gibt auch Mechanismen, um Ihre eigenen Abhängigkeiten in einen AWS Glue-Job in einer Scala- oder Python-Umgebung zu laden. Weitere Informationen zu Python-Abhängigkeiten finden Sie unter [Python-Bibliotheken mit AWS Glue verwenden](aws-glue-programming-python-libraries.md).
Weitere Beispiele für die Verwendung von AWS Glue-Funktionen in Python finden Sie unter[Beispiele für Python-Code in AWS Glue](aws-glue-programming-python-samples.md). Scala- und Python-Aufträge haben Feature-Parität, daher sollten unsere Python-Beispiele Ihnen einen Eindruck davon geben, wie Sie ähnliche Aufgaben in Scala ausführen können.