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.
# Orchestrierung in AWS Glue
In den folgenden Abschnitten erhalten Sie Informationen zum Orchestrierung von Aufträgen in AWS Glue.
**Topics**
+ [Starten von Aufträgen und Crawlern über Auslöser](trigger-job.md)
+ [Ausführen von komplexen ETL-Aktivitäten mithilfe von Blueprints und Workflows in AWS Glue](orchestrate-using-workflows.md)
+ [Entwickeln von Blueprints in AWS Glue](orchestrate-using-blueprints.md)
# Starten von Aufträgen und Crawlern über Auslöser
In AWS Glue können Sie Data-Catalog-Objekte erstellen, die als Auslöser bezeichnet werden und mit denen Sie entweder manuell oder automatisch einen oder mehrere Crawler starten oder ETL-Aufträge (Extrahieren, Transformieren und Laden) ausführen können. Mithilfe von Auslösern können Sie eine Kette von abhängigen Aufträgen und Crawlern entwerfen.
**Anmerkung**
Sie können dasselbe erreichen, indem Sie *Workflows* definieren. Für die Erstellung komplexer ETL-Operationen mit mehreren Aufträgen werden Workflows bevorzugt. Weitere Informationen finden Sie unter [Ausführen von komplexen ETL-Aktivitäten mithilfe von Blueprints und Workflows in AWS Glue](orchestrate-using-workflows.md).
**Topics**
+ [AWS Glue-Auslöser](about-triggers.md)
+ [Hinzufügen von Auslösern](console-triggers.md)
+ [Aktivieren und Deaktivieren von Auslösern](activate-triggers.md)
# AWS Glue-Auslöser
Wenn ein Auslöser *ausgelöst* wird, kann er angegebene Aufträge und Crawler starten. Ein Auslöser wird nach Bedarf, basierend auf einem Zeitplan oder basierend auf einer Kombination von Ereignissen ausgelöst.
**Anmerkung**
Nur zwei Crawler können durch einen einzigen Auslöser aktiviert werden. Wenn Sie das Crawling für mehrere Datenspeicher durchfühern möchten, verwenden Sie mehrere Quellen für jeden Crawler, anstatt mehrere Crawler gleichzeitig auszuführen.
Ein Auslöser kann einen von mehreren Zuständen besitzen. Ein Auslöser ist entweder `CREATED`, `ACTIVATED` oder `DEACTIVATED`. Es gibt auch Übergangszustände, wie z. B. `ACTIVATING`. Um einen Auslöser vorübergehend zu stoppen, können Sie ihn deaktivieren. Sie können ihn dann später wieder aktivieren.
Es gibt drei Arten von Auslösern:
**Geplant**
Ein zeitbasierter Auslöser basierend auf `cron`.
Sie können einen Auslöser für eine Gruppe von Aufträgen oder Crawlern basierend auf einem Zeitplan erstellen. Sie können Einschränkungen angeben, z. B. mit welcher Häufigkeit Aufträge oder Crawler ausgeführt werden sowie an welchen Wochentagen und zu welcher Uhrzeit sie ausgeführt werden. Diese Einschränkungen basieren auf `cron`. Wenn Sie einen Zeitplan für einen Auslöser aufstellen, berücksichtigen Sie die Features und Einschränkungen von cron. Wenn Sie z. B. Ihren Crawler jeden Monat am 31. ausführen möchten, denken Sie daran, dass einige Monate keine 31 Tage haben. Weitere Informationen zu cron finden Sie unter [Zeitpläne für Aufträge und Crawler](monitor-data-warehouse-schedule.md).
**Bedingt**
Ein Auslöser, der ausgelöst wird, wenn ein vorheriger Auftrag oder Crawler oder mehrere Aufträge oder Crawler eine Liste von Bedingungen erfüllen.
Wenn Sie einen bedingten Auslöser erstellen, geben Sie eine Liste der Aufträge und eine Liste der Crawlern an, die zu beobachten sind. Für jeden überwachten Auftrag oder Crawler geben Sie einen zu überwachenden Status an, z. B. erfolgreich, fehlgeschlagen, Zeitüberschreitung usw. Der Auslöser wird ausgelöst, wenn die überwachten Aufträge oder Crawler im angegebenen Zustand enden. Sie können den Auslöser so konfigurieren, dass er ausgelöst wird, wenn eines oder alle der überwachten Ereignisse eintreten.
Beispielsweise können Sie den Auslöser T1 zum Starten von Auftrag J3 konfigurieren, wenn sowohl Auftrag J1 als auch Auftrag J2 erfolgreich abgeschlossen wurden, und den weiteren Auslöser T2, um Auftrag J4 zu starten, wenn entweder Auftrag J1 oder Auftrag J2 fehlschlägt.
In der folgenden Tabelle sind die Auftrags- und Crawler-Abschlusszustände (Ereignisse) aufgeführt, nach denen Auslöser suchen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/about-triggers.html)
**On-Demand**
Ein Auslöser, der ausgelöst wird, wenn Sie ihn aktivieren. On-Demand-Auslöser gelangen niemals in den Zustand `ACTIVATED` oder `DEACTIVATED`. Sie verbleiben immer im Zustand `CREATED`.
Damit sie sofort ausgelöst werden können, sobald sie vorhanden sind, können Sie ein Flag zum Aktivieren geplanter und bedingter Auslöser beim Erstellen durch Sie festlegen.
**Wichtig**
Aufträge oder Crawler, die bedingt durch andere Aufträge oder Crawler ausgeführt werden, werden als *abhängig* bezeichnet. Abhängige Aufträge oder Crawler werden nur gestartet, wenn der abschließende Auftrag oder Crawler durch einen Auslöser gestartet wurde. Alle Aufträge oder Crawler in einer Abhängigkeitskette müssen abhängige Elemente eines einzelnen **Schedule (Zeitplan)**- oder **on-demand (On-Demand)**-Auslösers sein.
**Übergeben von Auftragsparametern mit Auslösern**
Ein Auslöser kann Parameter an die Aufträge übergeben, die durch ihn gestartet werden. Zu den Parametern gehören Auftragsargumente, Timeout-Wert, Sicherheitskonfiguration und mehr. Wenn der Auslöser mehrere Aufträge startet, werden die Parameter an jeden Auftrag übergeben.
Im Folgenden werden die Regeln für Auftragsargumente aufgeführt, die durch einen Auslöser übergeben werden:
+ Wenn der Schlüssel im Schlüssel-Wert-Paar mit einem Standard-Auftragsargument übereinstimmt, überschreibt das übergebene Argument das Standardargument. Wenn der Schlüssel mit keinem Standardargument übereinstimmt, wird das Argument als zusätzliches Argument an den Auftrag übergeben.
+ Wenn der Schlüssel im Schlüssel-Wert-Paar mit einem nicht überschreibbaren Argument übereinstimmt, wird das übergebene Argument ignoriert.
Weitere Informationen finden Sie unter [Auslöser](aws-glue-api-jobs-trigger.md) in der AWS Glue-API.
# Hinzufügen von Auslösern
Sie können einen Trigger mithilfe der AWS Glue Konsole, der AWS Command Line Interface (AWS CLI) oder der AWS Glue API hinzufügen.
**So fügen Sie einen Auslöser hinzu (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und ö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 unter **ETL** die Option **Triggers (Auslöser)** aus. Wählen Sie dann **Add trigger (Auslöser hinzufügen)**.
1. Geben Sie die folgenden Eigenschaften an:
**Name**
Geben Sie dem Auslöser einen eindeutigen Namen.
**Auslösertyp**
Geben Sie eines der folgenden Elemente an:
+ **Schedule (Zeitplan)**: Der Auslöser wird mit einer bestimmten Häufigkeit und zu einem bestimmten Zeitpunkt ausgelöst.
+ **Job events (Jobereignisse)**: Ein bedingter Auslöser. Der Auslöser wird ausgelöst, wenn ein oder alle Aufträge in der Liste mit ihren designierten Zuständen übereinstimmen. Damit der Auslöser ausgelöst wird, müssen die überwachten Aufträge durch Auslöser gestartet worden sein. Für jeden ausgewählten Auftrag können Sie nur ein Auftragsereignis (Abschlusszustand) beobachten.
+ **On-demand (On-Demand)**: Der Auslöser wird ausgelöst, wenn er aktiviert wird.
1. Führen Sie den Auslöser-Assistenten aus. Auf der Seite **Review (Überprüfen)** können Sie durch **Schedule (Zeitplan)** und **Job events (Auftragsereignisse)** bedingte Auslöser sofort aktivieren, indem Sie **Enable trigger on creation (Auslöser bei der Erstellung aktivieren)** auswählen.
**So fügen Sie einen Auslöser hinzu (AWS CLI)**
+ Verwenden Sie einen Befehl ähnlich dem folgenden.
```
aws glue create-trigger --name MyTrigger --type SCHEDULED --schedule "cron(0 12 * * ? *)" --actions CrawlerName=MyCrawler --start-on-creation
```
Dieser Befehl erstellt einen Zeitplan-Auslöser mit dem Namen `MyTrigger`, der jeden Tag um 12:00 Uhr UTC ausgeführt wird und einen Crawler mit dem Namen `MyCrawler` startet. Der Auslöser wird im aktivierten Zustand erstellt.
Weitere Informationen finden Sie unter [AWS Glue-Auslöser](about-triggers.md).
# Zeitpläne für Aufträge und Crawler
Sie können einen Zeitplan für Ihre Crawler und Aufträge in AWS Glue definieren. Die Definition dieser Zeitpläne verwendet die Unix-ähnliche [Cron](http://en.wikipedia.org/wiki/Cron)-Syntax. Sie geben die Zeit in [UTC (Coordinated Universal Time, koordinierte Weltzeit)](http://en.wikipedia.org/wiki/Coordinated_Universal_Time) an. Die minimale Genauigkeit für einen Zeitplan beträgt 5 Minuten.
Weitere Informationen zum Konfigurieren von Aufträgen und Crawlern für die Ausführung mit einem Zeitplan finden Sie unter [Starten von Aufträgen und Crawlern über Auslöser](trigger-job.md).
## Cron-Ausdrücke
Cron-Ausdrücke verfügen über sechs Pflichtfelder, die durch Leerzeichen voneinander getrennt sind.
**Syntax**
```
cron(Minutes Hours Day-of-month Month Day-of-week Year)
```
| **Felder** | **Werte** | **Platzhalter** |
| --- | --- | --- |
| Minuten | 0-59 | , - \$1 / |
| Stunden | 0–23 | , - \$1 / |
| D ay-of-month | 1-31 | , - \$1 ? / L W |
| Monat | 1-12 oder JAN-DEZ | , - \$1 / |
| D ay-of-week | 1-7 oder SO-SA | , - \$1 ? / L |
| Jahr | 1970-2199 | , - \$1 / |
**Platzhalter**
+ Das Platzhalterzeichen **,** (Komma) schließt zusätzliche Werte ein. Im Feld `Month` würde `JAN,FEB,MAR` Januar, Februar und März abdecken.
+ Das Platzhalterzeichen **-** (Bindestrich) gibt einen Bereich an. Im Feld `Day` steht 1-15 für die Tage 1 bis 15 des angegebenen Monats.
+ Das Platzhalterzeichen **\$1** (Sternchen) steht für alle Werte im Feld. Im Feld `Hours` steht **\$1** für alle Stunden.
+ Das Platzhalterzeichen **/** (Schrägstrich) steht für schrittweise Steigerungen. Im Feld `Minutes` können Sie **1/10** eingeben, um einen Bereich von je 10 Minuten beginnend mit der ersten Minute der Stunde anzugeben (z. B. die 11., 21. und 31. Minute usw.).
+ Das Platzhalterzeichen **?** (Fragezeichen) steht für einen Wert. In das `Day-of-month` Feld könntest du **7** eingeben, und wenn es dir egal wäre, welcher Wochentag der siebte war, könntest du eingeben**?** auf dem Day-of-week Feld.
+ Das Platzhalterzeichen **L** in den Feldern für `Day-of-month` oder `Day-of-week` gibt den letzten Tag des Monats oder der Woche an.
+ Das Platzhalterzeichen **W** im Feld `Day-of-month` gibt einen Wochentag an. Im Feld `Day-of-month` gibt den `3W` den Tag an, der dem dritten Tag des Monats am nächsten ist.
**Einschränkungen**
+ Es ist nicht möglich, die Felder `Day-of-month` und `Day-of-week` im gleichen Cron-Ausdruck anzugeben. Wenn Sie einen Wert in einem der Felder angeben, müssen Sie in dem anderen Feld ein **?** (Fragezeichen) eingeben.
+ Cron-Ausdrücke, die zu schnelleren Häufigkeiten als mit 5 Minuten führen, werden nicht unterstützt.
**Beispiele**
Wenn Sie einen Zeitplan erstellen, können Sie die folgenden Beispiel-Cron-Strings verwenden.
| Minuten | Stunden | Tag des Monats | Monat | Wochentag | Jahr | Bedeutung |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 10 | \$1 | \$1 | ? | \$1 | Ausführung jeden Tag um 10:00 Uhr (UTC) |
| 15 | 12 | \$1 | \$1 | ? | \$1 | Ausführung jeden Tag um 12:15 Uhr (UTC) |
| 0 | 18 | ? | \$1 | MO-FR | \$1 | Ausführung jeden Montag bis Freitag um 18:00 Uhr (UTC) |
| 0 | 8 | 1 | \$1 | ? | \$1 | Ausführung jeden 1. Tag des Monats um 08:00 Uhr (UTC) |
| 0/15 | \$1 | \$1 | \$1 | ? | \$1 | Ausführung alle 15 Minuten |
| 0/10 | \$1 | ? | \$1 | MO-FR | \$1 | Ausführung alle 10 Minuten von Montag bis Freitag |
| 0/5 | 8-17 | ? | \$1 | MO-FR | \$1 | Ausführung alle 5 Minuten von Montag bis Freitag zwischen 08:00 Uhr und 17:55 Uhr (UTC) |
Wenn Sie beispielsweise etwas täglich um 12:15 UTC ausführen möchten, geben Sie Folgendes an:
```
cron(15 12 * * ? *)
```
# Aktivieren und Deaktivieren von Auslösern
Sie können einen Trigger mithilfe der AWS Glue Konsole, der AWS Command Line Interface (AWS CLI) oder der AWS Glue API aktivieren oder deaktivieren.
**So aktivieren oder deaktivieren Sie einen Auslöser (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und ö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 unter **ETL** die Option **Triggers (Auslöser)** aus.
1. Aktivieren Sie das Kontrollkästchen neben dem gewünschten Auslöser und wählen Sie im Menü **Action (Aktion)** die Option **Enable trigger (Auslöser aktivieren)**, um den Auslöser zu aktivieren, oder **Disable trigger (Auslöser deaktivieren)**, um den Auslöser zu deaktivieren.
**So aktivieren oder deaktivieren Sie einen Auslöser (AWS CLI)**
+ Geben Sie einen der folgenden Befehle ein.
```
aws glue start-trigger --name MyTrigger
aws glue stop-trigger --name MyTrigger
```
Ein Auslöser wird beim Starten aktiviert und beim Stoppen deaktiviert. Wenn Sie einen On-Demand-Auslöser aktivieren, wird er sofort ausgelöst.
Weitere Informationen finden Sie unter [AWS Glue-Auslöser](about-triggers.md).
# Ausführen von komplexen ETL-Aktivitäten mithilfe von Blueprints und Workflows in AWS Glue
Einige ETL-Prozesse (Extract, Transform, Load) Ihrer Organisation können am besten mithilfe mehrerer, abhängiger AWS Glue-Aufträge und Crawler implementiert werden. Mithilfe von AWS Glue-*Workflows* können Sie einen komplexen Multi-Job-ETL-Prozess mit mehreren Crawlern entwerfen, der von AWS Glue kann als einzelne Entität ausgeführt und verfolgt werden kann. Nachdem Sie einen Workflow erstellt und die Aufträge, Crawler und Trigger im Workflow angegeben haben, können Sie den Workflow bei Bedarf oder nach einem Zeitplan ausführen.
**Topics**
+ [Übersicht über Workflows in AWS Glue](workflows_overview.md)
+ [Manuelles Erstellen und Aufbauen eines Workflows in AWS Glue](creating_running_workflows.md)
+ [Einen AWS Glue Workflow mit einem EventBridge Amazon-Event starten](starting-workflow-eventbridge.md)
+ [EventBridge Ereignisse anzeigen, die einen Workflow gestartet haben](viewing-start-event-info.md)
+ [Ausführen und Überwachen eines Workflows in AWS Glue](running_monitoring_workflow.md)
+ [Anhalten einer Workflow-Ausführung](workflow-stopping.md)
+ [Reparieren und Fortsetzen einer Workflow-Ausführung](resuming-workflow.md)
+ [Abrufen und Festlegen von Ausführungseigenschaften für Workflows in AWS Glue](workflow-run-properties-code.md)
+ [Abfragen von Workflows mit dem AWS Glue API](workflows_api_concepts.md)
+ [Blueprint- und Workflow-Einschränkungen in AWS Glue](blueprint_workflow_restrictions.md)
+ [Beheben von Blueprint-Fehlern in AWS Glue](blueprint_workflow_troubleshoot.md)
+ [Berechtigungen für Personas und Rollen für AWS Glue-Blueprints](blueprints-personas-permissions.md)
# Übersicht über Workflows in AWS Glue
In AWS Glue können Sie mit Workflows komplexe ETL-Aktivitäten (Extrahieren, Transformieren und Laden) mit mehreren Crawlern, Aufträgen und Auslösern erstellen und darstellen. Jeder Workflow verwaltet die Ausführung und Überwachung aller zugehöriger Aufträge und Crawler. Wenn ein Workflow seine Komponenten ausführt, werden der Fortschritt und der Status der Ausführung aufgezeichnet. So erhalten Sie eine Übersicht über die Aufgabe und die Details der einzelnen Schritte. Die AWS Glue-Konsole bietet eine grafische Darstellung eines Workflows als Diagramm.
Sie können einen Workflow anhand eines AWS Glue Blueprints erstellen, oder Sie können manuell einen Workflow komponentenweise mit dem AWS-Managementkonsole oder dem AWS Glue API erstellen. Weitere Informationen über Pläne finden Sie unter [Übersicht über Blueprints in AWS Glue](blueprints-overview.md).
*Auslöser* innerhalb von Workflows können Aufträge und Crawler starten sowie von Aufträgen und Crawlern aktiviert werden. Mithilfe von Auslösern können Sie große Ketten voneinander abhängiger Aufträge und Crawler erstellen. Zusätzlich zu Auslösern in einem Workflow, die Auftrags- und Crawler-Abhängigkeiten definieren, verfügt jeder Workflow über einen *Startauslöser*. Es gibt drei Arten von Startauslösern:
+ **Zeitplan** – Der Workflow wird entsprechend einem von Ihnen festgelegten Zeitplan gestartet. Der Start kann z. B. täglich, wöchentlich oder monatlich erfolgen, der Zeitplan kann aber auch benutzerdefiniert sein und auf einem `cron`-Ausdruck basieren.
+ **Bei Bedarf** — Der Workflow wird manuell über die AWS Glue Konsole, API oder AWS CLI gestartet.
+ **EventBridge Ereignis** — Der Workflow wird beim Eintreten eines einzelnen EventBridge Amazon-Ereignisses oder einer Reihe von EventBridge Amazon-Ereignissen gestartet. Bei diesem Auslösertyp kann AWS Glue ein Ereigniskonsument in einer ereignisgesteuerten Architektur sein. Jeder EventBridge Ereignistyp kann einen Workflow starten. Ein häufiger Anwendungsfall ist die Ankunft eines neuen Objekts in einem Amazon-S3-Bucket (der S3-Vorgang `PutObject`).
Der Start eines Workflows mit einem Batch von Ereignissen impliziert, dass gewartet wird, bis eine bestimmte Anzahl von Ereignissen empfangen wurde oder bis eine bestimmte Zeitspanne verstrichen ist. Wenn Sie den EventBridge Ereignisauslöser erstellen, können Sie optional Batch-Bedingungen angeben. Wenn Sie Batchbedingungen angeben, müssen Sie die Batchgröße (Anzahl der Ereignisse) und optional ein Batchfenster (Anzahl der Sekunden) angeben. Das standardmäßige und maximale Batchfenster beträgt 900 Sekunden (15 Minuten). Die Batchbedingung, die zuerst erfüllt ist, startet den Workflow. Das Batchfenster beginnt, wenn das erste Ereignis eintrifft. Wenn Sie beim Erstellen eines Auslösers keine Batchbedingungen angeben, wird die Batchgröße standardmäßig auf 1 gesetzt.
Beim Start des Workflows werden die Batchbedingungen zurückgesetzt und der Ereignisauslöser beginnt zu überwachen, ob die nächste Batchbedingung für den erneuten Start des Workflows erfüllt ist.
In der folgenden Tabelle wird gezeigt, wie Batchgröße und Batchfenster bei der Auslösung eines Workflows zusammenarbeiten.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/workflows_overview.html)
Die `GetWorkflowRun`-API-Operation gibt die Batchbedingung zurück, die den Workflow ausgelöst hat.
Unabhängig davon, wie ein Workflow gestartet wird, können Sie beim Erstellen des Workflows die maximale Anzahl gleichzeitiger Workflow-Ausführungen angeben.
Wenn ein Ereignis oder ein Batch von Ereignissen eine Workflow-Ausführung startet, die fehlschlägt, wird dieses Ereignis oder dieser Batch von Ereignissen nicht mehr für den Start einer Workflow-Ausführung berücksichtigt. Eine neue Workflow-Ausführung wird erst gestartet, wenn das nächste Ereignis oder der nächste Batch von Ereignissen eintrifft.
**Wichtig**
Beschränken Sie die Gesamtzahl der Aufträge, Crawler und Trigger innerhalb eines Workflows auf 100 oder weniger. Wenn Sie mehr als 100 einschließen, werden möglicherweise Fehler angezeigt, wenn Sie versuchen, Workflow-Läufe fortzusetzen oder zu beenden.
Eine Workflow-Ausführung wird nicht gestartet, wenn sie das für den Workflow festgelegte Parallelitätslimit überschreitet – auch wenn die Ereignisbedingung erfüllt ist. Sie sollten Workflow-Parallelitätslimits gemäß dem erwarteten Ereignisvolumen anpassen. Workflow-Ausführungen, die aufgrund von überschrittenen Parallelitätslimits fehlschlagen, werden von AWS Glue nicht erneut ausgeführt. Ebenso empfiehlt es sich, Parallelitätslimits für Aufträge und Crawler innerhalb von Workflows je nach dem erwarteten Ereignisvolumen anzupassen.
**Eigenschaften von Workflow-Ausführungen**
Zum Freigeben und Verwalten des Zustands während der Ausführung eines Workflows können Sie Standard-Ausführungseigenschaften für den Workflow definieren. Diese Eigenschaften, bei denen es sich um name/value Paare handelt, sind für alle Jobs im Workflow verfügbar. Mithilfe von können Jobs die AWS Glue API Eigenschaften der Workflow-Ausführung abrufen und sie für Jobs ändern, die später im Workflow erscheinen.
**Workflow-Diagramm**
Die folgende Abbildung zeigt das Diagramm eines sehr einfachen Workflows in der AWS Glue-Konsole. Ein Workflow kann Dutzende von Komponenten umfassen.
![\[Konsolen-Screenshot mit der Registerkarte „Graph (Diagramm)“ für einen Workflow. Das Diagramm enthält fünf Symbole, die einen Zeitplanauslöser, zwei Aufträge, einen Auslöser bei einem erfolgreichen Ereignis sowie einen Crawler darstellen, der das Schema aktualisiert.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/graph-complete-with-tabs.png)
Dieser Workflow wird von einem Zeitplanauslöser (`Month-close1`) gestartet, der zwei Aufträge startet, `De-duplicate` und `Fix phone numbers`. Nach erfolgreichem Abschluss beider Aufträge startet ein Ereignisauslöser (`Fix/De-dupe succeeded`) einen Crawler (`Update schema`).
**Statische und dynamische Workflow-Ansichten**
Für jeden Workflow gibt es eine *statische* und eine *dynamische Ansicht*. Die statische Ansicht zeigt die Struktur des Workflows. Die dynamische Ansicht ist eine Laufzeitansicht, die die aktuellen Ausführungsinformationen für alle Aufträge und Crawler enthält. Zu Ausführungsinformationen gehören zu Erfolgsstatus und Fehlerdetails.
Während ein Workflow ausgeführt wird, wird in der Konsole die dynamische Ansicht angezeigt. Diese stellt die abgeschlossenen und noch ausstehenden Aufträge grafisch dar. Sie können auch mit der AWS Glue API eine dynamische Ansicht eines aktiven Workflows abrufen. Weitere Informationen finden Sie unter [Abfragen von Workflows mit dem AWS Glue API](workflows_api_concepts.md).
**Weitere Informationen finden Sie auch unter**
[Erstellen eines Workflows aus einem Blueprint in AWS Glue](creating_workflow_blueprint.md)
[Manuelles Erstellen und Aufbauen eines Workflows in AWS Glue](creating_running_workflows.md)
[Arbeitsabläufe](aws-glue-api-workflow.md) (für die Workflow-API)
# Manuelles Erstellen und Aufbauen eines Workflows in AWS Glue
Sie können die AWS Glue-Konsole verwenden, um einen Workflow Knoten für Knoten zu erstellen und aufzubauen.
Ein Workflow enthält Aufträge, Crawler und Auslöser. Erstellen Sie vor dem manuellen Erstellen eines Workflows die Aufträge und Crawler, die der Workflow enthalten soll. Es empfiehlt sich, run-on-demand Crawler für Workflows anzugeben. Sie können neue Auslöser erstellen, während Sie Ihren Workflow erstellen, oder Sie können vorhandene Auslöser in den Workflow *klonen*. Wenn Sie einen Auslöser klonen, werden alle dem Auslöser zugeordneten Katalogobjekte – die Aufträge oder Crawler, die ihn auslösen, sowie die Aufträge oder Crawler, die er startet, dem Workflow hinzugefügt.
**Wichtig**
Beschränken Sie die Gesamtzahl der Aufträge, Crawler und Trigger innerhalb eines Workflows auf 100 oder weniger. Wenn Sie mehr als 100 einschließen, werden möglicherweise Fehler angezeigt, wenn Sie versuchen, Workflow-Läufe fortzusetzen oder zu beenden.
Der Workflow wird weiter bearbeitet, indem Sie dem Workflow-Diagramm Auslöser hinzufügen und die überwachten Ereignisse und Aktionen für jeden Auslöser definieren. Sie beginnen mit einem *Startauslöser*. Dabei kann es sich um einen On-Demand-Auslöser oder einen Zeitplanauslöser handeln. Dann schließen Sie das Diagramm ab, indem Sie Ereignisauslöser (bedingte Auslöser) hinzufügen.
## Schritt 1: Erstellen des Workflows
1. Melden Sie sich bei der an AWS-Managementkonsole und ö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 unter **ETL** die Option **Workflows** aus.
1. Wählen Sie **Add Workflow (Workflow hinzufügen)** aus und füllen Sie das Formular **Add a new ETL workflow (Neuen ETL-Workflow hinzufügen)** aus.
Alle optionalen Standard-Ausführungseigenschaften, die Sie hinzufügen, werden als Argumente für alle Aufträge im Workflow verfügbar gemacht. Weitere Informationen finden Sie unter [Abrufen und Festlegen von Ausführungseigenschaften für Workflows in AWS Glue](workflow-run-properties-code.md).
1. Wählen Sie **Add Workflow (Workflow hinzufügen)** aus.
Der neue Workflow wird in der Liste auf der Seite **Workflows** angezeigt.
## Schritt 2: Hinzufügen eines Startauslösers
1. Wählen Sie auf der Seite **Workflows** den neuen Workflow aus. Wählen Sie unten auf der Seite die Registerkarte **Graph (Diagramm)** aus.
1. Wählen Sie **Add trigger (Auslöser hinzufügen)** aus und führen Sie im Dialogfeld **Add trigger (Auslöser hinzufügen)** einen der folgenden Schritte aus:
+ Wählen Sie **Clone existing (Vorhandenen klonen)** aus und wählen Sie einen vorhandenen Auslöser aus, den Sie klonen möchten. Wählen Sie dann **Add (Hinzufügen)**.
Der Auslöser wird im Diagramm angezeigt, zusammen mit den Aufträgen und Crawlern, die er überwacht, sowie den Aufträgen und Crawlern, die er startet.
Wenn Sie versehentlich den falschen Auslöser ausgewählt haben, wählen Sie den Auslöser im Diagramm aus und klicken Sie dann auf **Remove (Entfernen)**.
+ Wählen Sie **Add new (Neu)** aus und füllen Sie das Formular **Add trigger (Auslöser hinzufügen)** aus.
1. Wählen Sie als **Triggertyp** die Option **Zeitplan**, **Auf Abruf** oder **EventBridgeEreignis** aus.
Wählen Sie für den Auslösertyp **Schedule (Zeitplan)** eine der Optionen für **Frequency (Häufigkeit)** aus. Wählen Sie **Custom (Benutzerdefiniert)** aus und geben Sie einen `cron`-Ausdruck ein.
Geben Sie als **EventBridge Ereignis** vom Typ Trigger **die Anzahl der Ereignisse** (Stapelgröße) und optional **Zeitverzögerung** (Batchfenster) ein. Wenn Sie keinen Wert für **Time delay (Verzögerung)** angeben, wird das Batchzeitfenster standardmäßig auf 15 Minuten eingestellt. Weitere Informationen finden Sie unter [Übersicht über Workflows in AWS Glue](workflows_overview.md).
1. Wählen Sie **Hinzufügen** aus.
Der Auslöser wird im Diagramm mit einem Platzhalterknoten angezeigt. Dieser ist mit **Add node (Knoten hinzufügen**) markiert. Im folgenden Beispiel ist der Startauslöser ein Zeitplanauslöser namens `Month-close1`.
Bis jetzt wurde der Auslöser noch nicht gespeichert.
![\[Ein Diagramm mit zwei rechteckigen Knoten: ein Auslöser- und ein Platzhalterknoten. Ein Pfeil zeigt von Auslöserknoten zum Platzhalterknoten.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/graph-start-trigger.png)
1. Wenn Sie einen neuen Auslöser hinzugefügt haben, führen Sie die folgenden Schritte aus:
1. Führen Sie eine der folgenden Aktionen aus:
+ Wählen Sie den Platzhalterknoten mit der Bezeichnung **Add node (Knoten hinzufügen)** aus.
+ Stellen Sie sicher, dass der Start-Trigger ausgewählt ist, und wählen Sie im **Aktionsmenü** über dem Diagramm die Option ** jobs/crawlers Zum Trigger hinzufügen** aus.
1. Wählen Sie im Dialogfeld **Add jobs(s) and crawler(s) to trigger (Aufträge/Crawler zu Auslöser hinzufügen)** mindestens einen Auftrag oder Crawler aus. Klicken Sie dann auf **Add (Hinzufügen)**.
Der Auslöser wird gespeichert und die ausgewählten Aufträge oder Crawler werden im Diagramm mit Verbindungen zum Auslöser angezeigt.
Wenn Sie versehentlich die falschen Aufträge oder Crawler hinzugefügt haben, können Sie den Auslöser oder eine Verbindung auswählen und auf **Remove (Entfernen)** klicken.
## Schritt 3: Hinzufügen weiterer Auslöser
Sie können den Workflow erweitern und weitere Auslöser vom Typ **Event (Ereignis)** hinzufügen. Mit den Symbolen rechts neben dem Diagramm können Sie die Zeichenfläche vergrößern oder verkleinern. Führen Sie für jeden Auslöser, den Sie hinzufügen möchten, die folgenden Schritte aus:
**Anmerkung**
Es gibt keine Aktion, um den Workflow zu speichern. Nachdem Sie den letzten Auslöser hinzugefügt und ihm Aktionen zugewiesen haben, wird der Workflow abgeschlossen und gespeichert. Sie können jederzeit später weitere Knoten hinzufügen.
1. Führen Sie eine der folgenden Aktionen aus:
+ Wenn Sie einen vorhandenen Auslöser klonen möchten, stellen Sie sicher, dass kein Knoten im Diagramm ausgewählt ist. Wählen Sie dann im Menü **Action (Aktion)** die Option **Add trigger (Auslöser hinzufügen)** aus.
+ Wenn Sie einen neuen Auslöser hinzufügen möchten, der einen bestimmten Auftrag oder Crawler im Diagramm überwacht, wählen Sie den Auftrags- oder Crawler-Knoten aus. Wählen Sie dann den Platzhalterknoten **Add trigger (Auslöser hinzufügen)** aus.
In einem späteren Schritt können Sie weitere Aufträge oder Crawler hinzufügen, die diesen Auslöser überwachen.
1. Führen Sie im Dialogfeld **Add trigger (Auslöser hinzufügen)** einen der folgenden Schritte aus:
+ Wählen Sie **Add new (Neu)** aus und füllen Sie das Formular **Add trigger (Auslöser hinzufügen)** aus. Wählen Sie dann **Add (Hinzufügen)**.
Der Auslöser wird im Diagramm dargestellt. Sie stellen den Auslöser in einem späteren Schritt fertig.
+ Wählen Sie **Clone existing (Vorhandenen klonen)** aus und wählen Sie einen vorhandenen Auslöser aus, den Sie klonen möchten. Wählen Sie dann **Add (Hinzufügen)**.
Der Auslöser wird im Diagramm angezeigt, zusammen mit den Aufträgen und Crawlern, die er überwacht, sowie den Aufträgen und Crawlern, die er startet.
Wenn Sie versehentlich den falschen Auslöser ausgewählt haben, markieren Sie ihn im Diagramm und klicken Sie dann auf **Remove (Entfernen)**.
1. Wenn Sie einen neuen Auslöser hinzugefügt haben, führen Sie die folgenden Schritte aus:
1. Wählen Sie den neuen Trigger aus.
Der Auslöser `De-dupe/fix succeeded` ist ausgewählt und für zu überwachende Ereignisse (1) und Aktionen (2) werden Platzhalterknoten angezeigt, wie in der folgenden Abbildung dargestellt.
![\[Ein Diagramm mit mehreren Knoten. Zwei sind Platzhalterknoten mit der Nummerierung 1 und 2.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/graph-dual-placeholders.png)
1. (Optional, wenn der Auslöser bereits ein Ereignis überwacht und Sie weitere zu überwachende Aufträge oder Crawler hinzufügen möchten.) Wählen Sie den events-to-watch Platzhalterknoten und wählen **Sie im Dialogfeld Zu überwachende Jobs und Crawler hinzufügen** einen oder mehrere Jobs oder Crawler aus. Wählen Sie ein zu überwachendes Ereignis aus (SUCCEEDED, FAILED usw.) und klicken Sie auf **Add (Hinzufügen)**.
1. Stellen Sie sicher, dass der Auslöser ausgewählt ist, und wählen Sie den Platzhalterknoten für Aktionen aus.
1. Wählen Sie im Dialogfeld **Add job(s) and crawler(s) to watch (Zu überwachende Aufträge und Crawler hinzufügen)** mindestens einen Auftrag oder Crawler aus. Klicken Sie dann auf **Add (Hinzufügen)**.
Die ausgewählten Aufträge und Crawler werden im Diagramm mit Verbindungen zum Auslöser angezeigt.
Weitere Informationen zu Workflows und Blueprints finden Sie in den folgenden Themen.
+ [Übersicht über Workflows in AWS Glue](workflows_overview.md)
+ [Ausführen und Überwachen eines Workflows in AWS Glue](running_monitoring_workflow.md)
+ [Erstellen eines Workflows aus einem Blueprint in AWS Glue](creating_workflow_blueprint.md)
# Einen AWS Glue Workflow mit einem EventBridge Amazon-Event starten
Amazon EventBridge, auch bekannt als CloudWatch Events, ermöglicht es Ihnen, Ihre AWS Services zu automatisieren und automatisch auf Systemereignisse wie Probleme mit der Anwendungsverfügbarkeit oder Ressourcenänderungen zu reagieren. Ereignisse im AWS Rahmen von Services werden EventBridge nahezu in Echtzeit übermittelt. Sie können einfache Regeln schreiben, um anzugeben, welche Ereignisse für Sie interessant sind und welche automatisierten Aktionen durchgeführt werden sollen, wenn sich für ein Ereignis eine Übereinstimmung mit einer Regel ergibt.
Mit EventBridge Support AWS Glue kann er in einer ereignisgesteuerten Architektur als Produzent und Kunde von Veranstaltungen agieren. AWS GlueUnterstützt bei Workflows jede Art von EventBridge Ereignis als Verbraucher. Der wahrscheinlich häufigste Anwendungsfall ist die Ankunft eines neuen Objekts in einem Amazon-S3-Bucket. Wenn Daten in unregelmäßigen oder undefinierten Intervallen eintreffen, können Sie diese Daten so zeitnah wie möglich verarbeiten.
**Anmerkung**
AWS Gluebietet keine garantierte Zustellung von EventBridge Nachrichten. AWS Glueführt keine Deduplizierung durch, wenn doppelte Nachrichten EventBridge zugestellt werden. Sie müssen die Idempotenz auf der Grundlage Ihres Anwendungsfalls verwalten.
Achten Sie darauf, die EventBridge Regeln korrekt zu konfigurieren, um das Senden unerwünschter Ereignisse zu vermeiden.
**Bevor Sie beginnen**
Wenn Sie einen Workflow mit Amazon S3 S3-Datenereignissen starten möchten, müssen Sie sicherstellen, dass Ereignisse für den gewünschten S3-Bucket in AWS CloudTrail und protokolliert werden EventBridge. Dazu müssen Sie einen CloudTrail Trail erstellen. Weitere Informationen findest du unter [Einen Trail für dein AWS Konto](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html) erstellen.
**Um einen Workflow mit einem EventBridge Ereignis zu starten**
**Anmerkung**
Ersetzen Sie in den folgenden Befehlen …
**mit dem Namen, der dem Workflow zugewiesen werden soll.
**mit dem Namen, der dem Trigger zugewiesen werden soll.
**mit dem Namen des Amazon S3 S3-Buckets.
**mit einer gültigen AWS Konto-ID.
**mit dem Namen der Region (zum Beispiel`us-east-1`).
**mit dem Namen, der der EventBridge Regel zugewiesen werden soll.
1. Stellen Sie sicher, dass Sie über AWS Identity and Access Management (IAM-) Berechtigungen zum Erstellen und Anzeigen von EventBridge Regeln und Zielen verfügen. Nachfolgend finden Sie eine Musterrichtlinie, die Sie anfügen können. Möglicherweise sollten Sie sie eingrenzen, um Beschränkungen für die Vorgänge und Ressourcen festzulegen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"events:PutRule",
"events:DisableRule",
"events:DeleteRule",
"events:PutTargets",
"events:RemoveTargets",
"events:EnableRule",
"events:List*",
"events:Describe*"
],
"Resource": "*"
}
]
}
```
------
1. Erstellen Sie eine IAM-Rolle, die der EventBridge Dienst übernehmen kann, wenn er ein Ereignis weiterleitet. AWS Glue
1. Wählen Sie auf der Seite **Create role (Rolle erstellen)** der IAM-Konsole die Option **AWS -Service** aus. Wählen Sie dann den Service **CloudWatch Events** aus.
1. Schließen Sie den Assistenten **Create role (Rolle erstellen)** ab. Der Assistent fügt automatisch die Richtlinien `CloudWatchEventsBuiltInTargetExecutionAccess` und `CloudWatchEventsInvocationAccess` an.
1. Fügen Sie der Rolle die folgende Inline-Richtlinie an. Diese Richtlinie ermöglicht es dem EventBridge Dienst, Ereignisse an sie weiterzuleitenAWS Glue.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:notifyEvent"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:workflow/workflow-name"
]
}
]
}
```
------
1. Verwenden Sie den folgenden Befehl, um den Workflow zu erstellen.
Weitere Informationen zu zusätzlichen optionalen Befehlszeilenparametern finden Sie unter [create-workflow](https://docs.aws.amazon.com/cli/latest/reference/glue/create-workflow.html) in der *AWS CLI -Befehlsreferenz*.
```
aws glue create-workflow --name
```
1. Geben Sie den folgenden Befehl ein, um einen EventBridge Ereignisauslöser für den Workflow zu erstellen. Dies wird der Startauslöser für den Workflow sein. **Ersetzen Sie ihn durch die auszuführenden Aktionen (die Jobs und Crawler, die gestartet werden sollen).
Weitere Informationen zum Programmieren des `actions`-Arguments finden Sie unter [create-trigger](https://docs.aws.amazon.com/cli/latest/reference/glue/create-trigger.html) in der *AWS CLI -Befehlsreferenz*.
```
aws glue create-trigger --workflow-name --type EVENT --name --actions
```
Wenn Sie möchten, dass der Workflow durch eine Reihe von Ereignissen statt durch ein einzelnes EventBridge Ereignis ausgelöst wird, geben Sie stattdessen den folgenden Befehl ein.
```
aws glue create-trigger --workflow-name --type EVENT --name --event-batching-condition BatchSize=,BatchWindow= --actions
```
Für das `event-batching-condition`-Argument ist `BatchSize` erforderlich und `BatchWindow` optional. Wenn Sie `BatchWindow` weglassen, beträgt das Fenster standardmäßig 900 Sekunden – die maximale Fenstergröße.
**Example**
Im folgenden Beispiel wird ein Trigger erstellt, der den `eventtest` Workflow startet, nachdem drei EventBridge Ereignisse eingetroffen sind, oder fünf Minuten nach dem Eintreffen des ersten Ereignisses, je nachdem, was zuerst eintritt.
```
aws glue create-trigger --workflow-name eventtest --type EVENT --name objectArrival --event-batching-condition BatchSize=3,BatchWindow=300 --actions JobName=test1
```
1. Erstellen Sie eine Regel in Amazon EventBridge.
1. Erstellen Sie das JSON-Objekt für die Regeldetails in Ihrem bevorzugten Texteditor.
Im folgenden Beispiel wird Amazon S3 als Ereignisquelle, `PutObject` als Ereignisname und der Bucket-Name als Anforderungsparameter angegeben. Diese Regel startet einen Workflow, wenn ein neues Objekt im Bucket eintrifft.
```
{
"source": [
"aws.s3"
],
"detail-type": [
"AWS API Call via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"PutObject"
],
"requestParameters": {
"bucketName": [
""
]
}
}
}
```
Damit der Workflow gestartet wird, wenn ein neues Objekt in einem Ordner innerhalb des Buckets eintrifft, können Sie den folgenden Code für `requestParameters` austauschen.
```
"requestParameters": {
"bucketName": [
""
]
"key" : [{ "prefix" : "//*"}}]
}
```
1. Verwenden Sie Ihr bevorzugtes Tool, um das JSON-Regelobjekt in eine Zeichenfolge mit Escapezeichen zu konvertieren.
```
{\n \"source\": [\n \"aws.s3\"\n ],\n \"detail-type\": [\n \"AWS API Call via CloudTrail\"\n ],\n \"detail\": {\n \"eventSource\": [\n \"s3.amazonaws.com\"\n ],\n \"eventName\": [\n \"PutObject\"\n ],\n \"requestParameters\": {\n \"bucketName\": [\n \"\"\n ]\n }\n }\n}
```
1. Führen Sie den folgenden Befehl aus, um eine JSON-Parametervorlage zu erstellen, die Sie bearbeiten können, um Eingabeparameter für einen nachfolgenden `put-rule`-Befehl anzugeben. Speichern Sie die Ausgabe in einer Datei. In diesem Beispiel heißt die Datei `ruleCommand`.
```
aws events put-rule --name --generate-cli-skeleton >ruleCommand
```
Weitere Informationen zum Parameter `--generate-cli-skeleton` finden Sie unter [Generieren der AWS CLI -Skeleton- und -Eingabeparameter aus einer JSON- oder YAML-Eingabedatei](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) im *Benutzerhandbuch für die AWS -Befehlszeilenschnittstelle*.
Die Ausgabedatei sollte wie folgt aussehen.
```
{
"Name": "",
"ScheduleExpression": "",
"EventPattern": "",
"State": "ENABLED",
"Description": "",
"RoleArn": "",
"Tags": [
{
"Key": "",
"Value": ""
}
],
"EventBusName": ""
}
```
1. Bearbeiten Sie die Datei, um mindestens die Parameter `Name`, `EventPattern` und `State` festzulegen und optional Parameter zu entfernen. Geben Sie für den Parameter `EventPattern` die Zeichenfolge mit Escapezeichen für die Regeldetails an, die Sie in einem vorherigen Schritt erstellt haben.
```
{
"Name": "",
"EventPattern": "{\n \"source\": [\n \"aws.s3\"\n ],\n \"detail-type\": [\n \"AWS API Call via CloudTrail\"\n ],\n \"detail\": {\n \"eventSource\": [\n \"s3.amazonaws.com\"\n ],\n \"eventName\": [\n \"PutObject\"\n ],\n \"requestParameters\": {\n \"bucketName\": [\n \"\"\n ]\n }\n }\n}",
"State": "DISABLED",
"Description": "Start an AWS Glue workflow upon new file arrival in an Amazon S3 bucket"
}
```
**Anmerkung**
Es empfiehlt sich, die Regel deaktiviert zu lassen, bis Sie den Workflow fertig erstellt haben.
1. Geben Sie den folgenden `put-rule`-Befehl ein, der Eingabeparameter aus der Datei `ruleCommand` liest.
```
aws events put-rule --name --cli-input-json file://ruleCommand
```
Die folgende Ausgabe zeigt den Erfolg an.
```
{
"RuleArn": ""
}
```
1. Führen Sie den folgenden Befehl aus, um die Richtlinie einem Ziel anzufügen. Das Ziel ist der Workflow in AWS Glue. **Ersetzen Sie sie durch die Rolle, die Sie zu Beginn dieses Verfahrens erstellt haben.
```
aws events put-targets --rule --targets "Id"="1","Arn"="arn:aws:glue:::workflow/","RoleArn"="arn:aws:iam:::role/" --region
```
Die folgende Ausgabe zeigt den Erfolg an.
```
{
"FailedEntryCount": 0,
"FailedEntries": []
}
```
1. Bestätigen Sie die erfolgreiche Verbindung von Regel und Ziel, indem Sie den folgenden Befehl eingeben.
```
aws events list-rule-names-by-target --target-arn arn:aws:glue:::workflow/
```
Die folgende Ausgabe weist auf Erfolg hin. Dabei ** steht der Name der Regel, die Sie erstellt haben.
```
{
"RuleNames": [
""
]
}
```
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Wählen Sie den Workflow aus und prüfen Sie, ob der Startauslöser und seine Aktionen – die zu startenden Aufträge oder Crawler – im Workflow-Diagramm angezeigt werden. Fahren Sie anschließend mit dem Verfahren in [Schritt 3: Hinzufügen weiterer Auslöser](creating_running_workflows.md#workflow-step3) fort. Oder fügen Sie dem Workflow über die AWS Glue-API oder - AWS Command Line Interface weitere Komponenten hinzu.
1. Wenn der Workflow vollständig angegeben ist, aktivieren Sie die Regel.
```
aws events enable-rule --name
```
Der Workflow kann jetzt durch ein EventBridge Ereignis oder einen Ereignisstapel gestartet werden.
**Weitere Informationen finden Sie auch unter**
[https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)
[Übersicht über Workflows in AWS Glue](workflows_overview.md)
[Manuelles Erstellen und Aufbauen eines Workflows in AWS Glue](creating_running_workflows.md)
# EventBridge Ereignisse anzeigen, die einen Workflow gestartet haben
Sie können die Event-ID des EventBridge Amazon-Events einsehen, mit dem Ihr Workflow gestartet wurde. Wenn Ihr Workflow durch einen Stapel von Ereignissen gestartet wurde, können Sie das Ereignis IDs aller Ereignisse im Batch anzeigen.
Bei Workflows, deren Batchgröße größer als eins ist, können Sie außerdem sehen, welche Batchbedingung den Workflow gestartet hat: die Ankunft der Anzahl der Ereignisse in der Batchgröße oder der Ablauf des Batchfensters.
**Um die EventBridge Ereignisse anzuzeigen, die einen Workflow gestartet haben (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und ö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 die Option **Workflows** aus.
1. Wählen Sie den Workflow aus. Wählen Sie unten die Registerkarte **History (Verlauf)** aus.
1. Wählen Sie eine Workflow-Ausführung und dann die Option **View run details (Ausführungsdetails anzeigen)** aus.
1. Suchen Sie auf der Seite mit den Ausführungsdetails das Feld **Run properties (Ausführungseigenschaften)** und dann den Schlüssel **aws:eventIds**.
Der Wert für diesen Schlüssel ist eine Liste von EventBridge Ereignissen IDs.
**Um die EventBridge Ereignisse anzuzeigen, die einen Workflow (AWS API) gestartet haben**
+ Fügen Sie den folgenden Code in Ihr Python-Skript ein.
```
workflow_params = glue_client.get_workflow_run_properties(Name=workflow_name,RunId=workflow_run_id)
batched_events = workflow_params['aws:eventIds']
```
`batched_events` sollte eine Liste von Zeichenfolgen sein, die jeweils eine Ereignis-ID darstellen.
**Weitere Informationen finden Sie auch unter**
[https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)
[Übersicht über Workflows in AWS Glue](workflows_overview.md)
# Ausführen und Überwachen eines Workflows in AWS Glue
Wenn es sich bei dem Startauslöser für einen Workflow um einen On-Demand-Auslöser handelt, können Sie den Workflow über die AWS Glue-Konsole starten. Führen Sie die folgenden Schritte aus, um einen Workflow auszuführen und zu überwachen. Wenn der Workflow fehlschlägt, können Sie das Ausführungsdiagramm aufrufen, um den fehlgeschlagenen Knoten zu ermitteln. Wenn der Workflow mit einem Blueprint erstellt wurde, können Sie die Blueprint-Ausführung aufrufen, um die Blueprint-Parameterwerte anzuzeigen, die zum Erstellen des Workflows verwendet wurden. Weitere Informationen finden Sie unter [Anzeigen von Blueprint-Ausführungen in AWS Glue](viewing_blueprint_runs.md).
Sie können einen Workflow mit der AWS Glue-Konsole, -API oder - AWS Command Line Interface (AWS CLI) ausführen und überwachen.
**Einen Workflow ausführen und überwachen (Konsole)**
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 unter **ETL** die Option **Workflows** aus.
1. Wählen Sie einen Workflow aus. Wählen Sie im Menü **Actions (Aktionen)** die Option **Edit (Bearbeiten)** aus.
1. Überprüfen Sie die Spalte **Last run status (Status der letzten Ausführung)** in der Workflow-Liste. Wählen Sie die Schaltfläche „Refresh“ (Aktualisieren) aus, um den Status des laufenden Workflows anzuzeigen.
1. Während der Workflow ausgeführt wird oder nachdem er abgeschlossen wurde (oder fehlgeschlagen ist), können Sie die Ausführungsdetails abrufen. Dazu führen Sie die folgenden Schritte aus.
1. Wählen Sie den Workflow aus und gehen Sie auf die Registerkarte **History (Verlauf)**.
1. Wählen Sie die aktuelle oder letzte Workflow-Ausführung und dann **View run details (Ausführungsdetails anzeigen)** aus.
Das Workflow-Laufzeitdiagramm zeigt den aktuellen Ausführungsstatus an.
1. Wählen Sie einen beliebigen Knoten im Diagramm aus, um Details und Status des Knotens anzuzeigen.
![\[Das Laufdiagramm zeigt einen Startauslöser, der einen Auftrag startet. Ein weiterer Auslöser beobachtet den Auftragsabschluss. Der Auftragsknoten (ein Rechteck mit einem Zwischenablagesymbol und einem Auftragsnamen) ist ausgewählt und in einem Bereich auf der rechten Seite werden die Auftragsdetails angezeigt. Die Auftragsdetails umfassen die ID und den Status der Auftragsausführung.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/workflow-pre-select-resume.png)
**Einen Workflow ausführen und überwachen (AWS CLI)**
1. Geben Sie den folgenden Befehl ein. **Ersetzen Sie es durch den auszuführenden Workflow.
```
aws glue start-workflow-run --name
```
Wenn der Workflow erfolgreich gestartet wurde, gibt der Befehl die Ausführungs-ID zurück.
1. Rufen Sie mithilfe des Befehls `get-workflow-run` den Status der Workflow-Ausführung ab. Geben Sie den Namen und die Ausführungs-ID des Workflows an.
```
aws glue get-workflow-run --name myWorkflow --run-id wr_d2af14217e8eae775ba7b1fc6fc7a42c795aed3cbcd8763f9415452e2dbc8705
```
Hier sehen Sie eine beispielhafte Befehlsausgabe.
```
{
"Run": {
"Name": "myWorkflow",
"WorkflowRunId": "wr_d2af14217e8eae775ba7b1fc6fc7a42c795aed3cbcd8763f9415452e2dbc8705",
"WorkflowRunProperties": {
"run_state": "COMPLETED",
"unique_id": "fee63f30-c512-4742-a9b1-7c8183bdaae2"
},
"StartedOn": 1578556843.049,
"CompletedOn": 1578558649.928,
"Status": "COMPLETED",
"Statistics": {
"TotalActions": 11,
"TimeoutActions": 0,
"FailedActions": 0,
"StoppedActions": 0,
"SucceededActions": 9,
"RunningActions": 0,
"ErroredActions": 0
}
}
}
```
**Weitere Informationen finden Sie auch unter:**
[Übersicht über Workflows in AWS Glue](workflows_overview.md)
[Übersicht über Blueprints in AWS Glue](blueprints-overview.md)
# Anhalten einer Workflow-Ausführung
Sie können die AWS Glue Konsole AWS Command Line Interface (AWS CLI) oder die AWS Glue API verwenden, um einen Workflow-Lauf zu beenden. Wenn Sie einen Workflow anhalten, werden alle laufenden Aufgaben und Crawler sofort beendet und Aufgaben und Crawler, die noch nicht gestartet wurden, werden nie gestartet. Es kann bis zu einer Minute dauern, bis alle laufenden Aufgaben und Crawler beendet sind. Der Workflow-Ausführungsstatus wechselt von **Running (Wird ausgeführt)** zu **Stopping (Wird angehalten)**, und wenn die Workflow-Ausführung vollständig angehalten ist, wechselt der Status zu **Stopped (Angehalten)**.
Nachdem die Workflowlausführung angehalten wurde, können Sie das Ausführungsdiagramm anzeigen, um zu sehen, welche Aufgaben und Crawler abgeschlossen wurden und welche nie gestartet wurden. Anschließend können Sie ermitteln, ob Sie Schritte ausführen müssen, um die Datenintegrität zu gewährleisten. Das Anhalten einer Workflow-Ausführung führt dazu, dass keine automatischen Rollback-Operationen ausgeführt werden.
**So beenden Sie eine Workflow-Ausführung (Konsole):**
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 unter **ETL** die Option **Workflows** aus.
1. Wählen Sie einen derzeit ausgeführten Workflow und dann die Registerkarte **History (Verlauf)** aus.
1. Wählen Sie die Workflow-Ausführung aus und klicken Sie dann auf **Stop run (Ausführen beenden)**.
Der Ausführungsstatus ändert sich zu **Stopping (Wird angehalten)**.
1. (Optional) Wählen Sie die Workflow-Ausführung aus, wählen Sie **View run details (Ausführungsdetails anzeigen)** und überprüfen Sie das Ausführungsdiagramm.
**So beenden Sie eine Workflow-Ausführung (AWS CLI):**
+ Geben Sie den folgenden Befehl ein. **Ersetzen Sie es durch den Namen des Workflows und ** durch die Ausführungs-ID des Workflows, der beendet werden soll.
```
aws glue stop-workflow-run --name --run-id
```
Im Folgenden finden Sie ein Beispiel für den **stop-workflow-run**-Befehl.
```
aws glue stop-workflow-run --name my-workflow --run-id wr_137b88917411d128081069901e4a80595d97f719282094b7f271d09576770354
```
# Reparieren und Fortsetzen einer Workflow-Ausführung
Wenn ein oder mehrere Knoten (Aufträge oder Crawler) in einem Workflow nicht erfolgreich abgeschlossen werden, wurde der Workflow nur teilweise ausgeführt. Nachdem Sie die Ursachen ermittelt und Korrekturen vorgenommen haben, können Sie einen oder mehrere Knoten auswählen, von denen die Workflow-Ausführung fortgesetzt werden soll, und die Ausführung dann fortsetzen. Dadurch werden die ausgewählten Knoten und alle nachgelagerten Knoten ausgeführt.
**Topics**
+ [Fortsetzen einer Workflow-Ausführung: Funktionsweise](#resume-workflow-howitworks)
+ [Fortsetzen einer Workflow-Ausführung](#how-to-resume-workflow)
+ [Hinweise und Einschränkungen für die Fortsetzung von Workflow-Ausführungen](#resume-workflow-notes)
## Fortsetzen einer Workflow-Ausführung: Funktionsweise
Sehen Sie sich den Workflow W1 im folgenden Diagramm an.
![\[Auslöser werden in Rechtecken angezeigt und Aufträge in Kreisen. Auslöser T1 auf der linken Seite startet den Workflow durch die Ausführung von Auftrag J1. Nachgelagerte Auslöser und Aufträge sind vorhanden, aber da die Aufträge J2 und J3 fehlschlagen, werden nachgelagerte Auslöser und Aufträge als nicht ausgeführt angezeigt.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/workflow_W1.png)
Die Workflow-Ausführung läuft folgendermaßen ab:
1. Auslöser T1 startet Auftrag J1.
1. Der erfolgreiche Abschluss von J1 aktiviert T2 und T3, die die Aufträge J2 bzw. J3 ausführen.
1. J2 und J3 schlagen fehl.
1. Die Auslöser T4 und T5 hängen vom erfolgreichen Abschluss von J2 und J3 ab. Daher werden sie nicht aktiviert und die Aufträge J4 und J5 werden nicht ausgeführt. Workflow W1 wird nur teilweise ausgeführt.
Angenommen, die Probleme, die die Ausführung von J2 und J3 verhindern, werden behoben. J2 und J3 werden als Startpunkte ausgewählt, an denen die Workflow-Ausführung fortgesetzt werden soll.
![\[Die Aufträge J2 und J3 werden als Knoten markiert, die fortgesetzt werden sollen. Nachgelagerte Auslöser und Aufträge werden als erfolgreich ausgeführt angezeigt.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/workflow_W1_resumed.png)
Die Workflow-Ausführung wird folgendermaßen fortgesetzt:
1. Die Aufträge J2 und J3 werden erfolgreich ausgeführt.
1. Dadurch werden die Auslöser T4 und T5 aktiviert.
1. Die Aufträge J4 und J5 werden erfolgreich ausgeführt.
Die fortgesetzte Workflow-Ausführung wird als separate Ausführung mit einer neuen Ausführungs-ID erfasst. Wenn Sie den Workflow-Verlauf aufrufen, können Sie die vorherige Ausführungs-ID für jede Workflow-Ausführung einsehen. Im Beispiel im folgenden Screenshot hatte die Workflow-Ausführung mit der Ausführungs-ID `wr_c7a22...` (zweite Zeile) einen Knoten, der nicht abgeschlossen wurde. Der Benutzer hat das Problem behoben und die Workflow-Ausführung fortgesetzt, wodurch die Ausführungs-ID `wr_a07e55...` (erste Zeile) generiert wurde.
![\[Eine Tabelle auf der Registerkarte „History“ (Verlauf) für einen Workflow enthält zwei Zeilen, eine für jede Workflow-Ausführung. Die erste Zeile enthält die Ausführungs-ID und die vorherige Ausführungs-ID. Die zweite Zeile enthält nur eine Ausführungs-ID. Die vorherige Ausführungs-ID in der ersten Zeile entspricht der Ausführungs-ID in der zweiten Zeile.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/previous-run-id.png)
**Anmerkung**
Für den Rest dieses Artikels bezieht sich der Begriff „fortgesetzte Workflow-Ausführung“ auf die Ausführung, die beim Fortsetzen der vorherigen Workflow-Ausführung erstellt wurde. Die „ursprüngliche Workflow-Ausführung“ bezieht sich auf den Workflow, der nur teilweise ausgeführt wurde und deswegen fortgesetzt werden musste.
**Diagramm mit fortgesetzter Workflow-Ausführung**
In einer fortgesetzten Workflow-Ausführung ist das Ausführungsdiagramm vollständig, obwohl nur eine Teilmenge von Knoten ausgeführt wird. Die Knoten, die bei der fortgesetzten Workflow-Ausführung nicht ausgeführt wurden, werden daher aus dem Ausführungsdiagramm der ursprünglichen Workflow-Ausführung kopiert. Kopierte Auftrags- und Crawlerknoten, die Teil der ursprünglichen Workflow-Ausführung waren, enthalten Ausführungsdetails.
Betrachten Sie noch einmal den Workflow W1 im vorherigen Diagramm. Wenn die Ausführung mit J2 und J3 fortgesetzt wird, zeigt das Ausführungsdiagramm für die fortgesetzte Workflow-Ausführung alle Aufträge (J1 bis J5) und alle Auslöser (T1 bis T5) an. Die Ausführungsdetails für J1 werden aus der ursprünglichen Workflow-Ausführung kopiert.
**Snapshots der Workflow-Ausführung**
Wenn eine Workflow-Ausführung gestartet wird, erstellt AWS Glue einen Snapshot des Workflow-Entwurfsdiagramms. Dieser Snapshot wird für die Dauer der Workflow-Ausführung verwendet. Wenn Sie nach dem Start der Ausführung Änderungen an Auslösern vornehmen, wirken sich diese Änderungen nicht auf die aktuelle Workflow-Ausführung aus. Snapshots stellen sicher, dass Workflow-Ausführungen konsistent ablaufen.
Snapshots machen nur Auslöser unveränderlich. Änderungen, die Sie während der Workflow-Ausführung an nachgelagerten Aufträgen und Crawlern vornehmen, werden für die aktuelle Ausführung wirksam.
## Fortsetzen einer Workflow-Ausführung
Führen Sie diese Schritte aus, um eine Workflow-Ausführung fortzusetzen. Sie können eine Workflow-Ausführung mit der AWS Glue Konsole, der API oder AWS Command Line Interface (AWS CLI) fortsetzen.
**Eine Workflow-Ausführung fortsetzen (Konsole)**
1. Öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Melden Sie sich als Benutzer an, der Berechtigungen zum Anzeigen von Workflows und zum Fortsetzung von Workflow-Ausführungen hat.
**Anmerkung**
Um Workflow-Ausführungen wieder aufzunehmen, benötigen Sie die `glue:ResumeWorkflowRun` AWS Identity and Access Management (IAM) -Berechtigung.
1. Wählen Sie im Navigationsbereich die Option **Workflows** aus.
1. Wählen Sie einen Workflow und dann die Registerkarte **History (Verlauf)** aus.
1. Wählen Sie einen Workflow aus, der nur teilweise ausgeführt wurde, und gehen Sie auf **View run details (Ausführungsdetails anzeigen)**.
1. Wählen Sie im Ausführungsdiagramm den ersten (oder einzigen) Knoten aus, den Sie neu starten und von dem Sie die Workflow-Ausführung fortsetzen möchten.
1. Wählen Sie im Detailbereich rechts neben dem Diagramm das Kontrollkästchen **Resume (Fortsetzen)** aus.
![\[Das Ausführungsdiagramm zeigt drei Knoten, darunter einen fehlgeschlagenen Auftragsknoten. Der Bereich mit den Auftragsdetails auf der rechten Seite enthält das Kontrollkästchen „Resume“ (Fortsetzen).\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/workflow-pre-select-resume.png)
Die Farbe des Knotens ändert sich und oben rechts wird ein kleines Fortsetzungssymbol angezeigt.
![\[Die Änderung des Ausführungsdiagramms wird im Text beschrieben. Das Kontrollkästchen „Resume“ (Fortsetzen) ist aktiviert.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/workflow-post-select-resume.png)
1. Führen Sie die beiden vorherigen Schritte aus, um weitere Knoten neu zu starten.
1. Wählen Sie erneut **Resume (Fortsetzen)** aus.
**Eine Workflow-Ausführung fortsetzen (AWS CLI)**
1. Stellen Sie sicher, dass Sie die IAM-Berechtigung `glue:ResumeWorkflowRun` haben.
1. Rufen Sie den Knoten IDs für die Knoten ab, die Sie neu starten möchten.
1. Führen Sie für die ursprüngliche Workflow-Ausführung den Befehl `get-workflow-run` aus. Geben Sie den Workflow-Namen und die Ausführungs-ID an und fügen Sie die Option `--include-graph` hinzu, wie im folgenden Beispiel veranschaulicht. Rufen Sie die Ausführungs-ID von der Registerkarte **History (Verlauf)** in der Konsole ab oder führen Sie dazu den Befehl `get-workflow` aus.
```
aws glue get-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --include-graph
```
Der Befehl gibt die Knoten und Edges des Diagramms als großes JSON-Objekt zurück.
1. Suchen Sie die relevanten Knoten anhand der `Type`- und `Name`-Eigenschaften der Knotenobjekte.
Das folgende Beispiel zeigt ein Knotenobjekt aus der Ausgabe.
```
{
"Type": "JOB",
"Name": "test1_post_failure_4592978",
"UniqueId": "wnode_d1b2563c503078b153142ee76ce545fe5ceef66e053628a786ddd74a05da86fd",
"JobDetails": {
"JobRuns": [
{
"Id": "jr_690b9f7fc5cb399204bc542c6c956f39934496a5d665a42de891e5b01f59e613",
"Attempt": 0,
"TriggerName": "test1_aggregate_failure_649b2432",
"JobName": "test1_post_failure_4592978",
"StartedOn": 1595358275.375,
"LastModifiedOn": 1595358298.785,
"CompletedOn": 1595358298.785,
"JobRunState": "FAILED",
"PredecessorRuns": [],
"AllocatedCapacity": 0,
"ExecutionTime": 16,
"Timeout": 2880,
"MaxCapacity": 0.0625,
"LogGroupName": "/aws-glue/python-jobs"
}
]
}
}
```
1. Rufen Sie die Knoten-ID aus der `UniqueId`-Eigenschaft des Knotenobjekts ab.
1. Führen Sie den Befehl `resume-workflow-run` aus. Geben Sie den Workflow-Namen, die Ausführungs-ID und die durch Leerzeichen IDs getrennte Liste der Knoten an, wie im folgenden Beispiel gezeigt.
```
aws glue resume-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --node-ids wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3 wnode_d1b2563c503078b153142ee76ce545fe5ceef66e053628a786ddd74a05da86fd
```
Der Befehl gibt die Ausführungs-ID der fortgesetzten (neuen) Workflow-Ausführung und eine Liste der Knoten aus, die gestartet werden.
```
{
"RunId": "wr_2ada0d3209a262fc1156e4291134b3bd643491bcfb0ceead30bd3e4efac24de9",
"NodeIds": [
"wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3"
]
}
```
Beachten Sie Folgendes: Obwohl der Beispielbefehl `resume-workflow-run` zwei Knoten aufgeführt hat, die neu gestartet werden sollen, zeigt die Beispielausgabe an, dass nur ein Knoten neu gestartet werden würde. Der Grund dafür ist, dass ein Knoten dem anderen Knoten nachgelagert war und der nachgelagerte Knoten durch den normalen Ablauf des Workflows trotzdem neu gestartet würde.
## Hinweise und Einschränkungen für die Fortsetzung von Workflow-Ausführungen
Beachten Sie die folgenden Hinweise und Einschränkungen, wenn Sie Workflow-Ausführungen fortsetzen.
+ Sie können eine Workflow-Ausführung nur fortsetzen, wenn sie sich im Zustand `COMPLETED` befindet.
**Anmerkung**
Selbst wenn ein oder mehrere Knoten in einer Workflow-Ausführung nicht abgeschlossen werden, wird der Workflow-Ausführungsstatus als `COMPLETED` angezeigt. Sie sollten das Ausführungsdiagramm überprüfen, um alle Knoten zu ermitteln, die nicht erfolgreich abgeschlossen wurden.
+ Sie können eine Workflow-Ausführung von jedem Auftrags- oder Crawlerknoten fortsetzen, der bei der ursprünglichen Workflow-Ausführung ausgeführt werden sollte. Ein Workflow, der von einem Auslöserknoten ausgeführt wird, kann jedoch nicht fortgesetzt werden.
+ Beim Neustart eines Knotens wird sein Zustand nicht zurückgesetzt. Alle Daten, die teilweise verarbeitet wurden, werden nicht zurückgesetzt.
+ Sie können eine fehlgeschlagene Workflow-Ausführung mehrmals fortsetzen. Ein wiederaufgenommener Lauf kann jedoch nur noch einmal fortgesetzt werden. Für weitere Wiederholungen setzen Sie stattdessen den ursprünglichen fehlgeschlagenen Lauf fort
+ Wenn Sie zwei Knoten zum Neustart auswählen und sie voneinander abhängig sind, wird der vorgelagerte Knoten vor dem nachgelagerten Knoten ausgeführt. Im Grunde genommen ist die Auswahl des nachgelagerten Knotens redundant, da er gemäß dem normalen Ablauf des Workflows ausgeführt wird.
# Abrufen und Festlegen von Ausführungseigenschaften für Workflows in AWS Glue
Mit Ausführungseigenschaften für Workflows können Sie den Zustand zwischen den Aufträgen in Ihrem AWS Glue-Workflow freigeben und verwalten. Sie können Standard-Ausführungseigenschaften festlegen, wenn Sie den Workflow erstellen. Wenn die Aufträge ausgeführt werden, können sie die Werte der Ausführungseigenschaft abrufen und optional ändern, damit sie als Eingabe für Aufträge später im Workflow verwendet werden können. Wenn ein Auftrag eine Ausführungseigenschaft ändert, ist der neue Wert nur für die Ausführung des Workflows vorhanden. Die Standard-Ausführungseigenschaften sind nicht betroffen.
Wenn Ihr AWS Glue-Job nicht Teil eines Workflows ist, werden diese Eigenschaften nicht festgelegt.
Der folgende Python-Beispielcode aus einem ETL-Auftrag (Extrahieren, Transformieren und Laden) zeigt, wie die Ausführungseigenschaften für den Workflow abgerufen werden.
```
import sys
import boto3
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from awsglue.context import GlueContext
from pyspark.context import SparkContext
glue_client = boto3.client("glue")
args = getResolvedOptions(sys.argv, ['JOB_NAME','WORKFLOW_NAME', 'WORKFLOW_RUN_ID'])
workflow_name = args['WORKFLOW_NAME']
workflow_run_id = args['WORKFLOW_RUN_ID']
workflow_params = glue_client.get_workflow_run_properties(Name=workflow_name,
RunId=workflow_run_id)["RunProperties"]
target_database = workflow_params['target_database']
target_s3_location = workflow_params['target_s3_location']
```
Im folgenden Code wird die Ausführungseigenschaft `target_format` dann auf `'csv'` festgelegt.
```
workflow_params['target_format'] = 'csv'
glue_client.put_workflow_run_properties(Name=workflow_name, RunId=workflow_run_id, RunProperties=workflow_params)
```
Weitere Informationen finden Sie hier:
+ [GetWorkflowRunProperties Aktion (Python: get\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-GetWorkflowRunProperties)
+ [PutWorkflowRunProperties Aktion (Python: put\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-PutWorkflowRunProperties)
# Abfragen von Workflows mit dem AWS Glue API
AWS Glue bietet eine umfassende API für die Verwaltung von Workflows. Sie können mit der AWS Glue API eine statische Ansicht eines Workflows oder eine dynamische Ansicht eines aktiven Workflows abrufen. Weitere Informationen finden Sie unter [Arbeitsabläufe](aws-glue-api-workflow.md).
**Topics**
+ [Abfragen von statischen Ansichten](#workflows_api_concepts_static)
+ [Abfragen von dynamischen Ansichten](#workflows_api_concepts_dynamic)
## Abfragen von statischen Ansichten
Verwenden Sie die API-Operation `GetWorkflow`, um eine statische Ansicht mit der Struktur des Workflows abzurufen. Diese Operation gibt ein Diagramm aus Knoten und Edges zurück, wobei jeder Knoten für einen Auslöser, einen Auftrag oder einen Crawler steht. Edges definieren die Beziehungen zwischen Knoten. Diese werden durch Konnektoren (Pfeile) im Diagramm in der AWS Glue-Konsole dargestellt.
Sie können diesen Vorgang auch mit gängigen Bibliotheken zur Grafikverarbeitung wie NetworkX, igraph, JGraph T und dem Java Universal Network/Graph (JUNG) Framework verwenden. Da alle diese Bibliotheken Diagramme ähnlich darstellen, werden nur minimale Transformationen benötigt.
Die von dieser API zurückgegebene statische Ansicht entspricht der neuesten Definition der mit dem Workflow verknüpften Trigger am häufigsten up-to-date.
### Diagrammdefinition
Bei einem Workflow-Diagramm (G) handelt es sich um ein geordnetes Paar (N, E), wobei N eine Gruppe von Knoten darstellt und E eine Reihe von Edges. Ein *Knoten* ist ein Eckpunkt im Diagramm, der mit einer eindeutigen Nummer gekennzeichnet ist. Typen von Knoten sind Auslöser, Aufträge oder Crawler. Beispiel: `{name:T1, type:Trigger, uniqueId:1}, {name:J1, type:Job, uniqueId:2}`.
Ein *Edge* ist ein 2-Tupel in der Form (`src, dest`), wobei `src` und `dest` Knoten sind und es eine gerichtete Verbindung von `src` zu `dest` gibt.
### Beispiel zum Abfragen einer statischen Ansicht
Betrachten Sie einen bedingten Auslöser T, der den Auftrag J2 nach Abschluss des Auftrags J1 auslöst.
```
J1 ---> T ---> J2
```
Knoten: J1, T, J2
Edges: (J1, T), (T, J2)
## Abfragen von dynamischen Ansichten
Mit der API-Operation `GetWorkflowRun` können Sie eine dynamische Ansicht für einen aktiven Workflow abrufen. Diese Operation gibt dieselbe statische Ansicht des Diagramms sowie Metadaten im Zusammenhang mit der Workflow-Ausführung zurück.
Knoten, die im Aufruf `GetWorkflowRun` Aufträge darstellen, verfügen über eine Liste der Auftragsausführungen, die als Teil der letzten Ausführung des Workflows initiiert wurden. Mit dieser Liste können Sie den Ausführungsstatus für jeden Auftrag im Diagramm anzeigen. Für nachgelagerte Abhängigkeiten, die noch nicht ausgeführt wurden, ist dieses Feld auf `null` festgelegt. Anhand der im Diagramm dargestellten Informationen sehen Sie den aktuellen Status jedes Workflows zu jedem beliebigen Zeitpunkt.
Die dynamische Ansicht, die von dieser API zurückgegeben wird, basiert auf der statischen Ansicht, die beim Starten der Workflow-Ausführung vorhanden war.
*Beispiel zu Laufzeitknoten:* `{name:T1, type: Trigger, uniqueId:1}`, `{name:J1, type:Job, uniqueId:2, jobDetails:{jobRuns}}`, `{name:C1, type:Crawler, uniqueId:3, crawlerDetails:{crawls}}`
### Beispiel 1: Dynamische Ansicht
Das folgende Beispiel zeigt einen einfachen Workflow mit zwei Auslösern.
+ Knoten: t1, j1, t2, j2
+ Edges: (t1, j1), (j1, t2), (t2, j2)
Die `GetWorkflow`-Antwort enthält Folgendes.
```
{
Nodes : [
{
"type" : Trigger,
"name" : "t1",
"uniqueId" : 1
},
{
"type" : Job,
"name" : "j1",
"uniqueId" : 2
},
{
"type" : Trigger,
"name" : "t2",
"uniqueId" : 3
},
{
"type" : Job,
"name" : "j2",
"uniqueId" : 4
}
],
Edges : [
{
"sourceId" : 1,
"destinationId" : 2
},
{
"sourceId" : 2,
"destinationId" : 3
},
{
"sourceId" : 3,
"destinationId" : 4
}
}
```
Die `GetWorkflowRun`-Antwort enthält Folgendes.
```
{
Nodes : [
{
"type" : Trigger,
"name" : "t1",
"uniqueId" : 1,
"jobDetails" : null,
"crawlerDetails" : null
},
{
"type" : Job,
"name" : "j1",
"uniqueId" : 2,
"jobDetails" : [
{
"id" : "jr_12334",
"jobRunState" : "SUCCEEDED",
"errorMessage" : "error string"
}
],
"crawlerDetails" : null
},
{
"type" : Trigger,
"name" : "t2",
"uniqueId" : 3,
"jobDetails" : null,
"crawlerDetails" : null
},
{
"type" : Job,
"name" : "j2",
"uniqueId" : 4,
"jobDetails" : [
{
"id" : "jr_1233sdf4",
"jobRunState" : "SUCCEEDED",
"errorMessage" : "error string"
}
],
"crawlerDetails" : null
}
],
Edges : [
{
"sourceId" : 1,
"destinationId" : 2
},
{
"sourceId" : 2,
"destinationId" : 3
},
{
"sourceId" : 3,
"destinationId" : 4
}
}
```
### Beispiel 2: Mehrere Aufträge mit einem bedingten Auslöser
Das folgende Beispiel zeigt einen Workflow mit mehreren Aufträgen und einem bedingten Auslöser (t3).
```
Consider Flow:
T(t1) ---> J(j1) ---> T(t2) ---> J(j2)
| |
| |
>+------> T(t3) <-----+
|
|
J(j3)
Graph generated:
Nodes: t1, t2, t3, j1, j2, j3
Edges: (t1, j1), (j1, t2), (t2, j2), (j1, t3), (j2, t3), (t3, j3)
```
# Blueprint- und Workflow-Einschränkungen in AWS Glue
Folgende Einschränkungen gelten für Blueprints und Workflows.
## Einschränkungen für Blueprints
Berücksichtigen Sie die folgenden Einschränkungen für Blueprints:
+ Der Blueprint muss in derselben AWS Region registriert sein, in der sich der Amazon S3 S3-Bucket befindet.
+ Um Blueprints für mehrere AWS Konten gemeinsam zu nutzen, müssen Sie die Leseberechtigungen für das Blueprint-ZIP-Archiv in Amazon S3 erteilen. Kunden, die über Leseberechtigungen für ein Blueprint-ZIP-Archiv verfügen, können den Blueprint in ihrem AWS Konto registrieren und verwenden.
+ Die Blueprint-Parameter werden als einzelnes JSON-Objekt gespeichert. Die maximale Länge dieses Objekts beträgt 128 KB.
+ Die maximale unkomprimierte Größe des Blueprint-ZIP-Archivs beträgt 5 MB. Die maximale Größe beträgt 1 MB.
+ Beschränken Sie die Gesamtzahl der Aufträge, Crawler und Trigger innerhalb eines Workflows auf 100 oder weniger. Wenn Sie mehr als 100 einschließen, werden möglicherweise Fehler angezeigt, wenn Sie versuchen, Workflow-Läufe fortzusetzen oder zu beenden.
## Einschränkungen für Workflows
Berücksichtigen Sie die folgenden Einschränkungen für Workflows. Einige dieser Kommentare richten sich eher an einen Benutzer, der Workflows manuell erstellt.
+ Die maximale Batchgröße für einen EventBridge Amazon-Event-Trigger beträgt 100. Die maximale Fenstergröße beträgt 900 Sekunden (15 Minuten).
+ Ein Auslöser kann nur einem Workflow zugeordnet werden.
+ Es ist nur ein Startauslöser (On-Demand- oder Zeitplanauslöser) zulässig.
+ Wenn ein Auftrag oder Crawler in einem Workflow von einem Auslöser gestartet wird, der sich außerhalb des Workflows befindet, lösen Auslöser innerhalb des Workflows, die vom Abschluss des Auftrags oder des Crawlers abhängen (erfolgreich oder anderweitig), nicht aus.
+ Gleiches gilt, wenn ein Auftrag oder Crawler in einem Workflow über Auslöser verfügt, die vom Abschluss des Auftrags oder Crawlers (erfolgreich oder nicht erfolgreich) sowohl innerhalb als auch außerhalb des Workflows abhängen. Wenn der Auftrag oder Crawler von innerhalb eines Workflows gestartet wird, werden bei Abschluss des Auftrags oder Crawlers nur die Auslöser innerhalb des Workflows aktiviert.
# Beheben von Blueprint-Fehlern in AWS Glue
Sollten bei der Verwendung von AWS Glue-Blueprints Fehler auftreten, können Sie die folgenden Lösungen nutzen, um die Ursachen der Probleme zu finden und sie zu beheben.
**Topics**
+ [Fehler: PySpark Modul fehlt](#blueprint-workflow-error-1)
+ [Fehler: Blueprint-Konfigurationsdatei fehlt](#blueprint-workflow-error-2)
+ [Fehler: fehlende importierte Datei](#blueprint-workflow-error-3)
+ [Fehler iamPassRole : nicht autorisiert, auf der Ressource zu arbeiten](#blueprint-workflow-error-4)
+ [Fehler: Ungültiger Cron-Zeitplan](#blueprint-workflow-error-5)
+ [Fehler: Ein Auslöser mit demselben Namen ist bereits vorhanden](#blueprint-workflow-error-6)
+ [Fehler: Workflow mit Name: foo ist bereits vorhanden.](#blueprint-workflow-error-7)
+ [Fehler: Modul im angegebenen layoutGenerator-Pfad nicht gefunden](#blueprint-workflow-error-8)
+ [Fehler: Validierungsfehler im Feld „Connections“ (Verbindungen)](#blueprint-workflow-error-9)
## Fehler: PySpark Modul fehlt
AWS Gluegibt den Fehler „Unbekannter Fehler beim Ausführen der Layoutgeneratorfunktion ModuleNotFoundError: Kein Modul namens 'pyspark'“ zurück.
Wenn Sie das Blueprint-Archiv entpacken, sind zwei Szenarien möglich:
```
$ unzip compaction.zip
Archive: compaction.zip
creating: compaction/
inflating: compaction/blueprint.cfg
inflating: compaction/layout.py
inflating: compaction/README.md
inflating: compaction/compaction.py
$ unzip compaction.zip
Archive: compaction.zip
inflating: blueprint.cfg
inflating: compaction.py
inflating: layout.py
inflating: README.md
```
Im ersten Fall wurden alle zugehörigen Blueprint-Dateien unter einem Ordner namens „compaction“ (Komprimierung) abgelegt, der dann in eine ZIP-Datei namens *compaction.zip* konvertiert wurde.
Im zweiten Fall wurden alle für den Blueprint benötigten Dateien nicht in einen Ordner aufgenommen und als Stammdateien in die ZIP-Datei *compaction.zip* eingefügt.
Das Erstellen einer Datei in einem der oben genannten Formate ist erlaubt. Stellen Sie jedoch sicher, dass `blueprint.cfg` den richtigen Pfad zum Namen der Funktion in dem Skript hat, das das Layout generiert.
**Beispiele**
In Fall 1: `blueprint.cfg` sollte `layoutGenerator` wie folgt enthalten:
```
layoutGenerator": "compaction.layout.generate_layout"
```
In Fall 2: `blueprint.cfg` sollte `layoutGenerator` wie folgt enthalten:
```
layoutGenerator": "layout.generate_layout"
```
Wenn dieser Pfad nicht korrekt enthalten ist, könnte wie angegeben ein Fehler angezeigt werden. Wenn Sie beispielsweise die Ordnerstruktur wie in Fall 2 haben und den `layoutGenerator` wie in Fall 1, sehen Sie wahrscheinlich die obige Fehlermeldung.
## Fehler: Blueprint-Konfigurationsdatei fehlt
AWS Gluegibt den Fehler „Unbekannter Fehler beim Ausführen der Layoutgenerator-Funktion FileNotFoundError: [Errno 2] Keine solche Datei oder kein solches Verzeichnis: '/ tmp/compaction/blueprint .cfg'“ zurück.
Die blueprint.cfg sollte auf der Stammebene des ZIP-Archivs oder in einem Ordner platziert werden, der den gleichen Namen wie das ZIP-Archiv hat.
Wenn wir das Blueprint-ZIP-Archiv extrahieren, wird erwartet, dass sich die blueprint.cfg in einem der folgenden Pfade befindet. Wenn es nicht in einem der folgenden Pfade gefunden wird, sehen Sie wahrscheinlich die obige Fehlermeldung.
```
$ unzip compaction.zip
Archive: compaction.zip
creating: compaction/
inflating: compaction/blueprint.cfg
$ unzip compaction.zip
Archive: compaction.zip
inflating: blueprint.cfg
```
## Fehler: fehlende importierte Datei
AWS Gluegibt den Fehler „Unbekannter Fehler beim Ausführen der Layoutgenerator-Funktion FileNotFoundError: [Errno 2] Keine solche Datei oder kein solches Verzeichnis: \$1 \$1'demo-project/foo.py'“ zurück.
Wenn Ihr Skript zur Layoutgenerierung Funktionen zum Lesen anderer Dateien hat, stellen Sie sicher, dass Sie einen vollständigen Pfad für die zu importierende Datei angeben. Beispielsweise kann das Skript „Conversion.py“ in Layout.py referenziert werden. Weitere Informationen finden Sie unter [Blueprint-Beispielprojekt](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-sample.html).
## Fehler iamPassRole : nicht autorisiert, auf der Ressource zu arbeiten
AWS Gluegibt den Fehler „User: arn:aws:sts: :123456789012:assumed-“ zurück role/AWSGlueServiceRole/GlueSession is not authorized to perform: iam:PassRole on resource: arn:aws:iam::123456789012:role/AWSGlueServiceRole
Wenn die Aufträge und Crawler im Workflow dieselbe Rolle übernehmen, die zum Erstellen des Workflows vom Blueprint übergeben wurde, muss die Blueprint-Rolle die Berechtigung `iam:PassRole` für sich selbst enthalten.
Wenn die Aufträge und Crawler im Workflow eine Rolle übernehmen, die sich von der Rolle unterscheidet, die zum Erstellen der Entitäten des Workflows vom Blueprint übergeben wurde, muss die Blueprint-Rolle die Berechtigung `iam:PassRole` für diese andere Rolle enthalten.
Weitere Informationen finden Sie unter [Berechtigungen für Blueprint-Rollen](https://docs.aws.amazon.com/glue/latest/dg/blueprints-personas-permissions.html#blueprints-role-permissions).
## Fehler: Ungültiger Cron-Zeitplan
AWS Glue gibt den Fehler „The schedule cron(0 0 \$1 \$1 \$1 \$1) is invalid“ zurück.
Stellen Sie einen gültigen [cron](https://en.wikipedia.org/wiki/Cron)-Ausdruck bereit. Weitere Informationen finden Sie unter [Zeitbasierte Pläne für Aufträge und Crawler](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html).
## Fehler: Ein Auslöser mit demselben Namen ist bereits vorhanden
AWS Glue gibt den Fehler „Trigger with name 'foo\$1starting\$1trigger' already submitted with different configuration“ zurück.
Für einen Blueprint müssen Sie keine Auslöser im Layoutskript für die Workflow-Erstellung definieren. Die Auslösererstellung wird von der Blueprint-Bibliothek verwaltet und basiert auf den Abhängigkeiten, die zwischen zwei Aktionen definiert sind.
Die Auslöser werden wie folgt benannt:
+ Für den Startauslöser im Workflow lautet das Namensformat \$1starting\$1trigger.
+ Für einen Knoten (Auftrag/Crawler) im Workflow, der vom Abschluss eines oder mehrerer vorgelagerter Knoten abhängt, definiert AWS Glue einen Auslöser mit dem Namen \$1\$1trigger.
Dieser Fehler bedeutet, dass bereits ein Auslöser mit demselben Namen vorhanden ist. Sie können den vorhandenen Auslöser löschen und die Workflow-Erstellung erneut ausführen.
**Anmerkung**
Beim Löschen eines Workflows werden die Knoten im Workflow nicht gelöscht. Es ist möglich, dass beim Löschen eines Workflows Auslöser zurückbleiben. Sie können deshalb nicht die Fehlermeldung erhalten, dass ein Workflow bereits vorhanden ist. Es ist aber möglich, dass Sie die Fehlermeldung erhalten, dass ein Auslöser bereits vorhanden ist. Dies kann passieren, wenn Sie einen Workflow erstellen, wieder löschen und dann versuchen, ihn mit demselben Namen auf der Grundlage desselben Blueprints neu zu erstellen.
## Fehler: Workflow mit Name: foo ist bereits vorhanden.
Der Workflow-Name muss eindeutig sein. Geben Sie einen anderen Namen ein.
## Fehler: Modul im angegebenen layoutGenerator-Pfad nicht gefunden
AWS Gluegibt den Fehler „Unbekannter Fehler beim Ausführen der Layoutgenerator-Funktion: Kein Modul namens 'crawl\$1s3\$1locations'“ zurück. ModuleNotFoundError
```
layoutGenerator": "crawl_s3_locations.layout.generate_layout"
```
Wenn Sie beispielsweise den obigen layoutGenerator-Pfad haben, muss dieser beim Entpacken des Blueprint-Archivs wie folgt aussehen:
```
$ unzip crawl_s3_locations.zip
Archive: crawl_s3_locations.zip
creating: crawl_s3_locations/
inflating: crawl_s3_locations/blueprint.cfg
inflating: crawl_s3_locations/layout.py
inflating: crawl_s3_locations/README.md
```
Wenn Sie ein Blueprint-Archiv entpacken, das wie folgt aussieht, können Sie den obigen Fehler erhalten.
```
$ unzip crawl_s3_locations.zip
Archive: crawl_s3_locations.zip
inflating: blueprint.cfg
inflating: layout.py
inflating: README.md
```
Sie können sehen, dass kein Ordner namens `crawl_s3_locations` vorhanden ist, und wenn der Pfad `layoutGenerator` über das Modul`crawl_s3_locations` auf die Layoutdatei verweist, können Sie die obige Fehlermeldung erhalten.
## Fehler: Validierungsfehler im Feld „Connections“ (Verbindungen)
AWS Gluegibt den Fehler „Unbekannter Fehler bei der Ausführung der Layoutgenerator-Funktion zurück TypeError: Der Wert ['foo'] für die Tastenverbindungen sollte vom Typ sein\$1“.
Dies ist ein Validierungsfehler. Im Feld `Connections` in der `Job`-Klasse wird statt dem erwarteten Wörterbuch eine Liste von Werten bereitgestellt. Dies verursacht den Fehler.
```
User input was list of values
Connections= ['string']
Should be a dict like the following
Connections*=*{'Connections': ['string']}
```
Um diese Laufzeitfehler beim Erstellen eines Workflows anhand eines Blueprints zu vermeiden, können Sie die Workflow-, Auftrags- und Crawlerdefinitionen überprüfen, wie in [Testen eines Blueprints](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-testing.html) beschrieben.
In der [Referenz zu AWS Glue-Blueprint-Klassen](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-code-classes.html) finden Sie Informationen zur Syntax beim Definieren von AWS Glue-Aufträgen, -Crawlern und -Workflows im Layoutskript.
# Berechtigungen für Personas und Rollen für AWS Glue-Blueprints
Im Folgenden sind die typischen Personas und die empfohlenen AWS Identity and Access Management (IAM-) Berechtigungsrichtlinien für Personas und Rollen für Blueprints aufgeführt. AWS Glue
**Topics**
+ [Blueprint-Personas](#blueprints-personas)
+ [Berechtigungen für Blueprint-Personas](#blueprints-permssions)
+ [Berechtigungen für Blueprint-Rollen](#blueprints-role-permissions)
## Blueprint-Personas
Im Folgenden werden die Personas aufgeführt, die normalerweise am Lebenszyklus von AWS Glue-Blueprints beteiligt sind.
| Persona | Description |
| --- | --- |
| AWS GlueDeveloper | Entwickelt, testet und veröffentlicht Blueprints. |
| AWS Glue-Administrator | Registriert, verwaltet und erteilt Berechtigungen für Blueprints. |
| Datenanalyst | Führt Blueprints aus, um Workflows zu erstellen. |
Weitere Informationen finden Sie unter [Übersicht über Blueprints in AWS Glue](blueprints-overview.md).
## Berechtigungen für Blueprint-Personas
Im Folgenden finden Sie die empfohlenen Berechtigungen für die jeweiligen Blueprint-Personas.
### AWS Glue-Entwicklerberechtigungen für Blueprints
Der AWS Glue-Entwickler muss Schreibberechtigungen für den Amazon-S3-Bucket haben, der zum Veröffentlichen des Blueprints verwendet wird. Oft registriert der Entwickler den Blueprint, nachdem er ihn hochgeladen hat. In diesem Fall benötigt der Entwickler die Berechtigungen, die in [AWS Glue-Administratorberechtigungen für Blueprints](#bp-persona-admin) aufgeführt werden. Wenn der Entwickler den Blueprint nach der Registrierung testen möchte, benötigt er außerdem die Berechtigungen unter [Datenanalystenberechtigungen für Blueprints](#bp-persona-analyst).
### AWS Glue-Administratorberechtigungen für Blueprints
Mit der folgenden Richtlinie werden Berechtigungen zum Registrieren, Anzeigen und Verwalten von AWS Glue-Blueprints erteilt.
**Wichtig**
Ersetzen Sie in der folgenden Richtlinie ** und ** durch den Amazon S3 S3-Pfad zu den hochgeladenen Blueprint-ZIP-Archiven, um sich zu registrieren.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateBlueprint",
"glue:UpdateBlueprint",
"glue:DeleteBlueprint",
"glue:GetBlueprint",
"glue:ListBlueprints",
"glue:BatchGetBlueprints"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/prefix/*"
}
]
}
```
------
### Datenanalystenberechtigungen für Blueprints
Die folgende Richtlinie erteilt Berechtigungen zum Ausführen von Blueprints und zum Anzeigen des resultierenden Workflow- bzw. der Workflow-Komponenten. Außerdem gewährt sie `PassRole` für die Rolle, die AWS Glue übernimmt, um den Workflow und die Workflow-Komponenten zu erstellen.
Die Richtlinie gewährt Berechtigungen für jede Ressource. Wenn Sie einen differenzierten Zugriff auf einzelne Blueprints konfigurieren möchten, verwenden Sie das folgende Format für Blueprints: ARNs
```
arn:aws:glue:::blueprint/
```
**Wichtig**
Ersetzen Sie in der folgenden Richtlinie durch ein gültiges AWS Konto und ** ** ersetzen Sie es durch den Namen der Rolle, die zum Ausführen eines Blueprints verwendet wird. Die Berechtigungen, die für diese Rolle erforderlich sind, finden Sie unter [Berechtigungen für Blueprint-Rollen](#blueprints-role-permissions).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:ListBlueprints",
"glue:GetBlueprint",
"glue:StartBlueprintRun",
"glue:GetBlueprintRun",
"glue:GetBlueprintRuns",
"glue:GetCrawler",
"glue:ListTriggers",
"glue:ListJobs",
"glue:BatchGetCrawlers",
"glue:GetTrigger",
"glue:BatchGetWorkflows",
"glue:BatchGetTriggers",
"glue:BatchGetJobs",
"glue:BatchGetBlueprints",
"glue:GetWorkflowRun",
"glue:GetWorkflowRuns",
"glue:ListCrawlers",
"glue:ListWorkflows",
"glue:GetJob",
"glue:GetWorkflow",
"glue:StartWorkflowRun"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
## Berechtigungen für Blueprint-Rollen
Im Folgenden sehen Sie die vorgeschlagenen Berechtigungen für die IAM-Rolle, die zum Erstellen eines Workflows aus einem Blueprint verwendet wird. Die Rolle muss über eine Vertrauensstellung bei `glue.amazonaws.com` verfügen.
**Wichtig**
Ersetzen Sie es in der folgenden Richtlinie ** durch ein gültiges AWS Konto und ** ersetzen Sie es durch den Namen der Rolle.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateJob",
"glue:GetCrawler",
"glue:GetTrigger",
"glue:DeleteCrawler",
"glue:CreateTrigger",
"glue:DeleteTrigger",
"glue:DeleteJob",
"glue:CreateWorkflow",
"glue:DeleteWorkflow",
"glue:GetJob",
"glue:GetWorkflow",
"glue:CreateCrawler"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
**Anmerkung**
Wenn die Aufträge und Crawler im Workflow eine andere als diese Rolle übernehmen, muss diese Richtlinie die `iam:PassRole`-Berechtigung für die entsprechende Rolle einbinden, statt für die Blueprint-Rolle.
# Entwickeln von Blueprints in AWS Glue
Ihre Organisation verfügt möglicherweise über eine Reihe ähnlicher ETL-Anwendungsfälle, die davon profitieren können, dass sie einen einzelnen Workflow parametrisieren können, um sie alle zu verarbeiten. Für diesen Zweck können Sie in AWS Glue *Blueprints* definieren, mit denen Sie Workflows generieren können. Ein Blueprint akzeptiert Parameter. Ein Datenanalyst kann aus einem einzelnen Blueprint verschiedene Workflows ableiten, um ähnliche ETL-Anwendungsfälle zu verarbeiten. Einen fertigen Blueprint können Sie für verschiedene Abteilungen, Teams und Projekte wiederverwenden.
**Topics**
+ [Übersicht über Blueprints in AWS Glue](blueprints-overview.md)
+ [Entwickeln von Blueprints in AWS Glue](developing-blueprints.md)
+ [Registrieren eines Blueprints in AWS Glue](registering-blueprints.md)
+ [Anzeigen von Blueprints in AWS Glue](viewing_blueprints.md)
+ [Aktualisieren eines Blueprints in AWS Glue](updating_blueprints.md)
+ [Erstellen eines Workflows aus einem Blueprint in AWS Glue](creating_workflow_blueprint.md)
+ [Anzeigen von Blueprint-Ausführungen in AWS Glue](viewing_blueprint_runs.md)
# Übersicht über Blueprints in AWS Glue
**Anmerkung**
Die Blueprints-Funktion ist derzeit in den folgenden Regionen der AWS Glue-Konsole nicht verfügbar: Asien-Pazifik (Jakarta) und Naher Osten (VAE).
AWS Glue-Blueprints ermöglichen das Erstellen und Freigeben von AWS Glue-Workflows. Wenn es einen komplexen ETL-Prozess gibt, der für ähnliche Anwendungsfälle verwendet werden kann, können Sie einen Blueprint erstellen, anstatt mit AWS Glue für jeden Anwendungsfall einen eigenen Workflow anzulegen.
Im Blueprint sind die Aufträge und Crawler für den Workflow sowie die Parameter definiert, die der Workflow-Benutzer beim Ausführen des Blueprints angibt, um einen Workflow zu erstellen. Durch die Verwendung von Parametern lassen sich aus einem einzelnen Blueprint Workflows für verschiedene ähnliche Anwendungsfälle generieren. Weitere Informationen zu Workflows finden Sie unter [Übersicht über Workflows in AWS Glue](workflows_overview.md).
Im Folgenden sind Sie einige Anwendungsfälle für Blueprints beschrieben:
+ Sie möchten einen vorhandenen Datensatz partitionieren. Die Eingabeparameter für den Blueprint sind Amazon-Simple-Storage-Service(Amazon S3)-Quell- und -Zielpfade sowie eine Liste von Partitionsspalten.
+ Sie möchten einen Snapshot einer Amazon-DynamoDB-Tabelle in einem SQL-Datenspeicher wie Amazon Redshift erstellen. Die Eingabeparameter für den Blueprint sind der Name der DynamoDB-Tabelle und eine AWS Glue-Verbindung, in der ein Amazon-Redshift-Cluster und eine Zieldatenbank angeben sind.
+ Sie möchten CSV-Daten in mehreren Amazon-S3-Pfaden in Parquet konvertieren. Der AWS Glue-Workflow soll für jeden Pfad einen eigenen Crawler und Auftrag enthalten. Die Eingabeparameter sind die Zieldatenbank im AWS Glue Data Catalog und eine durch Komma getrennte Liste mit Amazon-S3-Pfaden. Beachten Sie, dass in diesem Fall die Anzahl der Crawler und Aufträge, die der Workflow erstellt, variabel ist.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/s3Bm8ay53Ms)
**Komponenten von Blueprints**
Ein Blueprint ist ein ZIP-Archiv, das die folgenden Komponenten enthält:
+ Ein Python-Layoutgenerator-Skript
Enthält eine Funktion, die das Workflow-*Layout* angibt – die Crawler und Aufträge, die für den Workflow erstellt werden sollen, die Auftrags- und Crawlereigenschaften sowie die Abhängigkeiten zwischen den Aufträgen und Crawlern. Die Funktion akzeptiert Blueprint-Parameter und gibt eine Workflowstruktur (JSON-Objekt) zurück, die AWS Glue verwendet, um den Workflow zu generieren. Da Sie ein Python-Skript zum Generieren des Workflows verwenden, können Sie Ihre eigene Logik hinzufügen, die auf Ihre Anwendungsfälle abgestimmt ist.
+ Eine Konfigurationsdatei
Gibt den vollständig qualifizierten Namen der Python-Funktion an, die das Workflow-Layout generiert. Gibt außerdem die Namen, Datentypen und andere Eigenschaften aller Blueprint-Parameter an, die vom Skript verwendet werden.
+ (Optional) ETL-Skripte und unterstützende Dateien
In einem erweiterten Anwendungsfall können Sie den Speicherort der ETL-Skripte, die Ihre Aufträge verwenden, parametrisieren. Sie können Auftragsskriptdateien in das ZIP-Archiv aufnehmen und einen Blueprint-Parameter für einen Amazon-S3-Speicherort angeben, in den die Skripte kopiert werden sollen. Das Layout-Generator-Skript kann die ETL-Skripte an den angegebenen Speicherort kopieren und diesen Speicherort als Pfadeigenschaft für das Auftragsskript angeben. Sie können auch Bibliotheken oder andere unterstützende Dateien einschließen, vorausgesetzt, Ihr Skript kann sie verarbeiten.
![\[Das Feld mit der Bezeichnung „Blueprint“ enthält zwei kleinere Felder, eines für das Python-Skript und das andere für die Konfigurationsdatei.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/blueprint.png)
**Blueprint-Ausführungen**
Wenn Sie einen Workflow aus einem Blueprint erstellen, führt AWS Glue den Blueprint aus. Dabei wird ein asynchroner Prozess gestartet, um den Workflow und die Aufträge, Crawler und Auslöser zu erstellen, die im Workflow gekapselt sind. AWS Glue verwendet die Blueprint-Ausfürhung, um die Erstellung des Workflows und seiner Komponenten zu orchestrieren. Der Ausführungsstatus des Blueprints informiert Sie über den Status des Erstellungsprozesses. Die Blueprint-Ausführung speichert auch die Werte, die Sie als Blueprint-Parameter angegeben haben.
![\[Das Feld „Blueprint run“ (Blueprint-Ausführung) enthält Symbole mit der Bezeichnung „Workflow“ und „Parameter Values (Parameterwerte).\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/blueprint-run.png)
Sie können Blueprint-Läufe mit der AWS Glue Konsole oder AWS Command Line Interface () anzeigen.AWS CLI Bei der Problembehandlung eines Workflows können Sie jederzeit die Blueprint-Ausführung anzeigen, um die Parameterwerte einzusehen, die zum Erstellen des Workflows verwendet wurden.
**Lebenszyklus eines Blueprints**
Blueprints werden in AWS Glue entwickelt, getestet und registriert und werden ausgeführt, um Workflows zu erstellen. Am Lebenszyklus von Blueprints sind in der Regel drei Personas beteiligt.
| Persona | Aufgaben |
| --- | --- |
| AWS GlueDeveloper | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/blueprints-overview.html) |
| AWS Glue-Administrator | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/blueprints-overview.html) |
| Datenanalyst | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/blueprints-overview.html) |
**Weitere Informationen finden Sie auch unter**
[Entwickeln von Blueprints in AWS Glue](developing-blueprints.md)
[Erstellen eines Workflows aus einem Blueprint in AWS Glue](creating_workflow_blueprint.md)
[Berechtigungen für Personas und Rollen für AWS Glue-Blueprints](blueprints-personas-permissions.md)
# Entwickeln von Blueprints in AWS Glue
Als AWS Glue-Entwickler können Sie Blueprints erstellen und veröffentlichen, die Datenanalysten zum Generieren von Workflows verwenden können.
**Topics**
+ [Übersicht über die Entwicklung von Blueprints](developing-blueprints-overview.md)
+ [Voraussetzungen für die Entwicklung von Blueprints](developing-blueprints-prereq.md)
+ [Schreiben des Blueprint-Codes](developing-blueprints-code.md)
+ [Blueprint-Beispielprojekt](developing-blueprints-sample.md)
+ [Testen eines Blueprints](developing-blueprints-testing.md)
+ [Veröffentlichen eines Blueprints](developing-blueprints-publishing.md)
+ [Referenz zu AWS Glue-Blueprint-Klassen](developing-blueprints-code-classes.md)
+ [Blueprint-Beispiele](developing-blueprints-samples.md)
**Weitere Informationen finden Sie auch unter**
[Übersicht über Blueprints in AWS Glue](blueprints-overview.md)
# Übersicht über die Entwicklung von Blueprints
Der erste Schritt im Entwicklungsprozess besteht darin, einen allgemeinen Anwendungsfall zu identifizieren, der von einem Blueprint profitieren würde. Ein typischer Anwendungsfall umfasst ein wiederkehrendes ETL-Problem, das auf allgemeine Weise gelöst werden sollte. Entwerfen Sie als Nächstes einen Blueprint, der den generalisierten Anwendungsfall implementiert, und definieren Sie die Blueprint-Eingabeparameter, die gemeinsam aus dem generalisierten Anwendungsfall einen spezifischen Anwendungsfall definieren können.
Ein Blueprint besteht aus einem Projekt, das eine Blueprint-Parameter-Konfigurationsdatei und ein Skript enthält, das das *Layout* des zu generierenden Workflows festlegt. Das Layout definiert die Aufträge und Crawler (oder *Entitäten* in Blueprint-Skript-Terminologie).
Sie geben im Layoutskript keine Auslöser direkt an. Stattdessen schreiben Sie Code, um die Abhängigkeiten zwischen den Aufträgen und Crawlern anzugeben, die das Skript erstellt. AWS Glue generiert die Auslöser auf der Grundlage Ihrer Abhängigkeitsangaben. Die Ausgabe des Layoutskripts ist ein Workflow-Objekt, das Spezifikationen für alle Workflowentitäten enthält.
Sie erstellen Ihr Workflow-Objekt mit den folgenden AWS Glue-Blueprint-Bibliotheken:
+ `awsglue.blueprint.base_resource` – Eine Bibliothek von Basisressourcen, die von den Bibliotheken verwendet werden.
+ `awsglue.blueprint.workflow` – Eine Bibliothek zum Definieren einer `Workflow`-Klasse.
+ `awsglue.blueprint.job` – Eine Bibliothek zum Definieren einer `Job`-Klasse.
+ `awsglue.blueprint.crawler` – Eine Bibliothek zum Definieren einer `Crawler`-Klasse.
Die einzigen anderen Bibliotheken, die zur Layoutgenerierung unterstützt werden, sind die für die Python-Shell verfügbaren Bibliotheken.
Bevor Sie Ihren Blueprint veröffentlichen, können Sie die in den Blueprint-Bibliotheken definierten Methoden verwenden, um den Blueprint lokal zu testen.
Wenn Sie bereit sind, den Blueprint für Datenanalysten verfügbar zu machen, verpacken Sie das Skript, die Parameterkonfigurationsdatei und alle unterstützenden Dateien, wie z. B. zusätzliche Skripts und Bibliotheken, in eine einzige bereitstellbare Komponente. Anschließend laden Sie die Komponente in Amazon S3 hoch und bitten einen Administrator, sie bei AWS Glue zu registrieren.
Informationen zu weiteren Blueprint-Beispielprojekten finden Sie unter [Blueprint-Beispielprojekt](developing-blueprints-sample.md) und [Blueprint-Beispiele](developing-blueprints-samples.md).
# Voraussetzungen für die Entwicklung von Blueprints
Um Blueprints zu entwickeln, sollten Sie mit der Verwendung von AWS Glue und dem Schreiben von Skripten für Apache-Spark-ETL- oder Python-Shell-Aufträge vertraut sein. Außerdem müssen Sie die folgenden Einrichtungsaufgaben abschließen.
+ Laden Sie vier AWS Python-Bibliotheken herunter, um sie in Ihren Blueprint-Layout-Skripten zu verwenden.
+ Richten Sie das AWS SDKs ein.
+ Richten Sie das ein AWS CLI.
## Herunterladen der Python-Bibliotheken
Laden Sie die folgenden Bibliotheken von GitHub herunter und installieren Sie sie in Ihrem Projekt:
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/base\$1resource.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/base_resource.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/workflow.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/workflow.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/.py tree/master/awsglue/blueprint/crawler](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/crawler.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/.py tree/master/awsglue/blueprint/job](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/job.py)
## Richten Sie das AWS Java-SDK ein
Für das AWS Java-SDK müssen Sie eine `jar` Datei hinzufügen, die die API für Blueprints enthält.
1. Falls Sie dies noch nicht getan haben, richten Sie das AWS SDK for Java ein.
+ Befolgen Sie für Java 1.x die Anweisungen unter [Einrichten des AWS SDK für Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html) im *AWS SDK für Java -Entwicklerhandbuch*.
+ Befolgen Sie für Java 2.x die Anweisungen unter [Einrichten des AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) im *AWS SDK for Java 2.x -Entwicklerhandbuch*.
1. Laden Sie die `jar` Client-Datei herunter, die Zugriff auf die APIs für Blueprints hat.
+ Für Java 1.x: s3://awsglue-custom-blueprints-preview- -1.11.x.jar artifacts/awsglue-java-sdk-preview/AWSGlueJavaClient
+ Für Java 2.x: s3://awsglue-custom-blueprints-preview- artifacts/awsglue-java-sdk-v2-preview/AwsJavaSdk -Glue-2.0.jar
1. Fügen Sie den Client `jar` an den Anfang des Java-Klassenpfads, um den vom Java-SDK bereitgestellten AWS Glue-Client zu überschreiben. AWS
```
export CLASSPATH=:$CLASSPATH
```
1. (Optional) Testen Sie das SDK mit der folgenden Java-Anwendung. Die Anwendung sollte eine leere Liste ausgeben.
Ersetzen Sie `accessKey` und `secretKey` mit Ihren Anmeldeinformationen und ersetzen Sie `us-east-1` mit Ihrer Region.
```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.glue.AWSGlue;
import com.amazonaws.services.glue.AWSGlueClientBuilder;
import com.amazonaws.services.glue.model.ListBlueprintsRequest;
public class App{
public static void main(String[] args) {
AWSCredentials credentials = new BasicAWSCredentials("accessKey", "secretKey");
AWSCredentialsProvider provider = new AWSStaticCredentialsProvider(credentials);
AWSGlue glue = AWSGlueClientBuilder.standard().withCredentials(provider)
.withRegion("us-east-1").build();
ListBlueprintsRequest request = new ListBlueprintsRequest().withMaxResults(2);
System.out.println(glue.listBlueprints(request));
}
}
```
## Richten Sie das AWS Python-SDK ein
Bei den folgenden Schritten wird davon ausgegangen, dass Sie Python Version 2.7 oder höher oder Version 3.9 oder höher auf Ihrem Computer installiert haben.
1. Laden Sie die folgende boto3-Wheel-Datei herunter. Wenn Sie zum Öffnen oder Speichern aufgefordert werden, speichern Sie die Datei. s3://awsglue-custom-blueprints-preview- artifacts/aws-python-sdk-preview/boto 3-1.17.31-py2.py3-none-any.whl
1. Laden Sie die folgende Botocore-Raddatei awsglue-custom-blueprints-preview herunter: artifacts/aws-python-sdk-preview/botocore s3://- -1.20.31-py2.py3-none-any.whl
1. Überprüfen Sie Ihre Python-Version.
```
python --version
```
1. Geben Sie je nach Python-Version die folgenden Befehle ein (für Linux):
+ Für Python 2.7 oder höher.
```
python3 -m pip install --user virtualenv
source env/bin/activate
```
+ Für Python 3.9 oder höher.
```
python3 -m venv python-sdk-test
source python-sdk-test/bin/activate
```
1. Installieren Sie die Botocore-Wheel-Datei.
```
python3 -m pip install /botocore-1.20.31-py2.py3-none-any.whl
```
1. Installieren Sie die boto3-Wheel-Datei.
```
python3 -m pip install /boto3-1.17.31-py2.py3-none-any.whl
```
1. Konfigurieren Sie Ihre Anmeldeinformationen und Standardregion in den Dateien `~/.aws/credentials` und`~/.aws/config`. Weitere Informationen finden Sie unter [Konfigurieren der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) im *AWS Command Line Interface -Leitfaden*.
1. (Optional) Testen Sie Ihre Einrichtung. Die folgenden Befehle sollten eine leere Liste zurückgeben.
Ersetzen Sie `us-east-1` durch Ihre Region.
```
$ python
>>> import boto3
>>> glue = boto3.client('glue', 'us-east-1')
>>> glue.list_blueprints()
```
## Richten Sie die Vorschau ein AWS CLI
1. Falls Sie dies noch nicht getan haben, installieren Sie and/or update the AWS Command Line Interface (AWS CLI) auf Ihrem Computer. Am einfachsten geht dies über `pip`, das Python-Installationsdienstprogramm:
```
pip install awscli --upgrade --user
```
Ausführliche Installationsanleitungen für die AWS CLI finden Sie unter [Installieren der AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
1. Laden Sie die AWS CLI Raddatei von: s3://awsglue-custom-blueprints-preview- artifacts/awscli-preview-build/awscli -1.19.31-py2.py3-none-any.whl herunter
1. Installiere die AWS CLI Raddatei.
```
python3 -m pip install awscli-1.19.31-py2.py3-none-any.whl
```
1. Führen Sie den Befehl `aws configure` aus. Konfigurieren Sie Ihre AWS Anmeldeinformationen (einschließlich Zugriffsschlüssel und geheimer Schlüssel) und AWS Region. Informationen zur Konfiguration von finden Sie AWS CLI hier: [Konfiguration der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
1. Testen Sie die AWS CLI. Der folgende Befehl sollte eine leere Liste zurückgeben.
Ersetzen Sie `us-east-1` durch Ihre Region.
```
aws glue list-blueprints --region us-east-1
```
# Schreiben des Blueprint-Codes
Jedes von Ihnen erstellte Blueprint-Projekt muss mindestens die folgenden Dateien enthalten:
+ Ein Python-Layoutskript, das den Workflow definiert. Das Skript enthält eine Funktion, die die Entitäten (Aufträge und Crawler) in einem Workflow und die Abhängigkeiten zwischen ihnen definiert.
+ Eine Konfigurationsdatei, `blueprint.cfg`, die Folgendes definiert:
+ Den vollständigen Pfad der Workflow-Layoutdefinitionsfunktion.
+ Die Parameter, die der Blueprint akzeptiert.
**Topics**
+ [Erstellen des Blueprint-Layoutskripts](developing-blueprints-code-layout.md)
+ [Erstellen der Konfigurationsdatei](developing-blueprints-code-config.md)
+ [Angeben der Blueprint-Parameter](developing-blueprints-code-parameters.md)
# Erstellen des Blueprint-Layoutskripts
Das Blueprint-Layoutskript muss eine Funktion enthalten, die die Entitäten in Ihrem Workflow generiert. Sie können diese Funktion benennen, wie immer Sie möchten. AWS Glue verwendet die Konfigurationsdatei, um den vollständig qualifizierten Namen der Funktion zu ermitteln.
Die Layoutfunktion führt Folgendes durch:
+ (Optional) Instanziiert die `Job`-Klasse, um `Job`-Objekte zu erstellen, und übergibt Argumente wie `Command` und `Role`. Dies sind Auftragseigenschaften, die Sie angeben, wenn Sie den Auftrag mit der AWS Glue-Konsole oder der API erstellen.
+ (Optional) Instanziiert die `Crawler`-Klasse, um `Crawler`-Objekte zu erstellen, und übergibt Argumente wie Name, Rolle und Ziel.
+ Übergibt die zusätzlichen Argumente `DependsOn` und `WaitForDependencies` an `Job()` und `Crawler()`, um Abhängigkeiten zwischen den Objekten (Workflow-Entitäten) anzugeben. Diese Argumente werden später in diesem Abschnitt erläutert.
+ Instanziiert die `Workflow`-Klasse, um das Workflow-Objekt zu erstellen, das an AWS Glue zurückgegeben wird. Dabei werden ein `Name`-Argument, ein `Entities`-Argument und ein optionales `OnSchedule`-Argument übergeben. Das `Entities`-Argument gibt alle Aufträge und Crawler an, die im Workflow enthalten sein sollen. Um zu erfahren, wie man ein `Entities`-Objekt aufbaut, sehen Sie sich das Beispielprojekt weiter unten in diesem Abschnitt an.
+ Gibt das `Workflow`-Objekt zurück.
Definitionen der Klassen `Job`, `Crawler` und `Workflow` finden Sie unter [Referenz zu AWS Glue-Blueprint-Klassen](developing-blueprints-code-classes.md).
Die Layoutfunktion muss die folgenden Eingabeargumente akzeptieren.
| Argument | Description |
| --- | --- |
| user\$1params | Python-Wörterbuch der Blueprint-Parameternamen und -werte. Weitere Informationen finden Sie unter [Angeben der Blueprint-Parameter](developing-blueprints-code-parameters.md). |
| system\$1params | Python-Wörterbuch, das zwei Eigenschaften enthält: region und accountId. |
Hier ist ein Layoutgenerator-Beispielskript in einer Datei namens `Layout.py`:
```
import argparse
import sys
import os
import json
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
def generate_layout(user_params, system_params):
etl_job = Job(Name="{}_etl_job".format(user_params['WorkflowName']),
Command={
"Name": "glueetl",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "2"
},
Role=user_params['PassRole'])
post_process_job = Job(Name="{}_post_process".format(user_params['WorkflowName']),
Command={
"Name": "pythonshell",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "2"
},
Role=user_params['PassRole'],
DependsOn={
etl_job: "SUCCEEDED"
},
WaitForDependencies="AND")
sample_workflow = Workflow(Name=user_params['WorkflowName'],
Entities=Entities(Jobs=[etl_job, post_process_job]))
return sample_workflow
```
Das Beispielskript importiert die erforderlichen Blueprint-Bibliotheken und enthält eine `generate_layout`-Funktion, die einen Workflow mit zwei Aufträgen generiert. Dies ist ein sehr einfaches Skript. Ein komplexeres Skript könnte zusätzliche Logik und Parameter verwenden, um einen Workflow mit vielen Aufträgen und Crawlern oder sogar einer variablen Anzahl von Aufträgen und Crawlern zu generieren.
## Das DependsOn Argument verwenden
Das `DependsOn`-Argument ist eine Wörterbuchdarstellung einer Abhängigkeit dieser Entität von anderen Entitäten innerhalb des Workflows. Es hat das folgende Format.
```
DependsOn = {dependency1 : state, dependency2 : state, ...}
```
Die Schlüssel in diesem Wörterbuch stellen die Objektreferenz, nicht den Namen, der Entität dar, während die Werte Zeichenfolgen sind, die dem Zustand entsprechen, auf den geachtet werden soll. AWS Glue leitet die richtigen Auslöser ab. Informationen zu den gültigen Zuständen finden Sie unter [Bedingungsstruktur](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-trigger.html#aws-glue-api-jobs-trigger-Condition).
Beispielsweise kann ein Auftrag vom erfolgreichen Abschluss eines Crawlers abhängen. Wenn Sie ein Crawler-Objekt namens `crawler2` wie folgt festlegen:
```
crawler2 = Crawler(Name="my_crawler", ...)
```
Dann enthält ein Objekt, das von `crawler2` abhängig ist, ein Konstruktor-Argument wie folgt:
```
DependsOn = {crawler2 : "SUCCEEDED"}
```
Zum Beispiel:
```
job1 = Job(Name="Job1", ..., DependsOn = {crawler2 : "SUCCEEDED", ...})
```
Wenn `DependsOn` für eine Entität weggelassen wird, hängt diese Entität vom Workflow-Startauslöser ab.
## Verwenden des WaitForDependencies Arguments
Das `WaitForDependencies`-Argument definiert, ob eine Auftrags- oder Crawler-Entität warten soll, bis *alle* Entitäten, von denen sie abhängig ist, abgeschlossen sind, oder bis *irgendeine* abgeschlossen ist.
Die zulässigen Werte sind „`AND`“ oder „`ANY`“.
## Verwenden des OnSchedule Arguments
Das `OnSchedule`-Argument für den `Workflow`-Klassenkonstruktor ist ein `cron`-Ausdruck, der die Startauslöserdefinition für einen Workflow definiert.
Wenn dieses Argument angegeben wird, erstellt AWS Glue einen Zeitplanauslöser mit dem entsprechenden Zeitplan. Wenn es nicht angegeben wird, ist der Startauslöser für den Workflow ein On-Demand-Auslöser.
# Erstellen der Konfigurationsdatei
Die Blueprint-Konfigurationsdatei ist eine erforderliche Datei, die den Skripteintrittspunkt zum Generieren des Workflows und die Parameter definiert, die der Blueprint akzeptiert. Die Datei muss mit `blueprint.cfg` benannt werden.
Hier ist eine Beispielkonfigurationsdatei.
```
{
"layoutGenerator": "DemoBlueprintProject.Layout.generate_layout",
"parameterSpec" : {
"WorkflowName" : {
"type": "String",
"collection": false
},
"WorkerType" : {
"type": "String",
"collection": false,
"allowedValues": ["G1.X", "G2.X"],
"defaultValue": "G1.X"
},
"Dpu" : {
"type" : "Integer",
"allowedValues" : [2, 4, 6],
"defaultValue" : 2
},
"DynamoDBTableName": {
"type": "String",
"collection" : false
},
"ScriptLocation" : {
"type": "String",
"collection": false
}
}
}
```
Die `layoutGenerator`-Eigenschaft gibt den vollständig qualifizierten Namen der Funktion in dem Skript an, das das Layout generiert.
Die `parameterSpec`-Eigenschaft gibt die Parameter an, die dieser Blueprint akzeptiert. Weitere Informationen finden Sie unter [Angeben der Blueprint-Parameter](developing-blueprints-code-parameters.md).
**Wichtig**
Ihre Konfigurationsdatei muss den Workflow-Namen als Blueprint-Parameter enthalten oder Sie müssen einen eindeutigen Workflow-Namen in Ihrem Layoutskript generieren.
# Angeben der Blueprint-Parameter
Die Konfigurationsdatei enthält Blueprint-Parameterspezifikationen in einem `parameterSpec`-JSON-Objekt. `parameterSpec` enthält ein oder mehrere Parameterobjekte.
```
"parameterSpec": {
"": {
"type": "",
"collection": true|false,
"description": "",
"defaultValue": ""
"allowedValues": ""
},
"": {
...
}
}
```
Im Folgenden sind die Regeln für die Codierung jedes Parameterobjekts aufgeführt:
+ Der Parametername und `type` sind obligatorisch. Alle anderen Eigenschaften sind optional.
+ Wenn Sie die `defaultValue`-Eigenschaft angeben, ist der Parameter optional. Anderenfalls ist der Parameter obligatorisch und der Datenanalyst, der einen Workflow aus dem Blueprint erstellt, muss dafür einen Wert angeben.
+ Wenn Sie die `collection`-Eigenschaft auf `true` festlegen, kann der Parameter eine Sammlung von Werten annehmen. Sammlungen können von einem beliebigen Datentyp sein.
+ Wenn Sie `allowedValues` angeben, wird in der AWS Glue-Konsole eine Dropdown-Liste mit Werten angezeigt, aus denen der Datenanalytiker beim Erstellen eines Workflows aus dem Blueprint wählen kann.
Die folgenden Werte sind für `type` zulässig:
| Parameterdatentyp | Hinweise |
| --- | --- |
| String | - |
| Integer | - |
| Double | - |
| Boolean | Mögliche Werte sind true und false. Generiert ein Kontrollkästchen auf der Seite Create a workflow from (Workflow aus erstellen) in der AWS Glue-Konsole. |
| S3Uri | Vollständiger Amazon-S3-Pfad, beginnend mit s3://. Generiert ein Textfeld und eine Browse (Durchsuchen)-Schaltfläche auf der Seite Create a workflow from (Workflow aus erstellen). |
| S3Bucket | Nur Amazon-S3-Bucket-Name. Generiert eine Bucket-Auswahl auf der Seite Create a workflow from (Workflow aus erstellen). |
| IAMRoleArn | Amazon-Ressourcenname (ARN) einer AWS Identity and Access Management (IAM) -Rolle. Generiert eine Rollenauswahl auf der Seite Create a workflow from (Workflow aus erstellen). |
| IAMRoleName | Name einer IAM-Rolle. Generiert eine Rollenauswahl auf der Seite Create a workflow from (Workflow aus erstellen). |
# Blueprint-Beispielprojekt
Die Datenformatkonvertierung ist ein häufiger Anwendungsfall für Extract, Transform, Load (ETL). In typischen analytischen Workloads werden spaltenbasierte Dateiformate wie Parquet und ORC gegenüber Textformaten wie CSV und JSON bevorzugt. Mit diesem Beispiel-Blueprint können Sie Daten CSV/JSON/etc von. in Parquet für Dateien auf Amazon S3 konvertieren.
Dieser Blueprint verwendet eine Liste von S3-Pfaden, die durch einen Blueprint-Parameter definiert sind, konvertiert die Daten ins Parquet-Format und schreibt sie in den von einem anderen Blueprint-Parameter angegebenen S3-Speicherort. Das Layoutskript erstellt einen Crawler und einen Auftrag für jeden Pfad. Das Layoutskript lädt auch das ETL-Skript in `Conversion.py` in einen S3-Bucket hoch, der durch einen anderen Blueprint-Parameter angegeben wird. Das Layoutskript gibt dann das hochgeladene Skript als ETL-Skript für jeden Auftrag an. Das ZIP-Archiv für das Projekt enthält das Layoutskript, das ETL-Skript und die Blueprint-Konfigurationsdatei.
Informationen zu weiteren Blueprint-Beispielprojekten finden Sie unter [Blueprint-Beispiele](developing-blueprints-samples.md).
Nachfolgend sehen Sie das Layoutskript in der Datei `Layout.py`.
```
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
import boto3
s3_client = boto3.client('s3')
# Ingesting all the S3 paths as Glue table in parquet format
def generate_layout(user_params, system_params):
#Always give the full path for the file
with open("ConversionBlueprint/Conversion.py", "rb") as f:
s3_client.upload_fileobj(f, user_params['ScriptsBucket'], "Conversion.py")
etlScriptLocation = "s3://{}/Conversion.py".format(user_params['ScriptsBucket'])
crawlers = []
jobs = []
workflowName = user_params['WorkflowName']
for path in user_params['S3Paths']:
tablePrefix = "source_"
crawler = Crawler(Name="{}_crawler".format(workflowName),
Role=user_params['PassRole'],
DatabaseName=user_params['TargetDatabase'],
TablePrefix=tablePrefix,
Targets= {"S3Targets": [{"Path": path}]})
crawlers.append(crawler)
transform_job = Job(Name="{}_transform_job".format(workflowName),
Command={"Name": "glueetl",
"ScriptLocation": etlScriptLocation,
"PythonVersion": "3"},
Role=user_params['PassRole'],
DefaultArguments={"--database_name": user_params['TargetDatabase'],
"--table_prefix": tablePrefix,
"--region_name": system_params['region'],
"--output_path": user_params['TargetS3Location']},
DependsOn={crawler: "SUCCEEDED"},
WaitForDependencies="AND")
jobs.append(transform_job)
conversion_workflow = Workflow(Name=workflowName, Entities=Entities(Jobs=jobs, Crawlers=crawlers))
return conversion_workflow
```
Nachfolgend sehen Sie die entsprechende Blueprint-Konfigurationsdatei `blueprint.cfg`.
```
{
"layoutGenerator": "ConversionBlueprint.Layout.generate_layout",
"parameterSpec" : {
"WorkflowName" : {
"type": "String",
"collection": false,
"description": "Name for the workflow."
},
"S3Paths" : {
"type": "S3Uri",
"collection": true,
"description": "List of Amazon S3 paths for data ingestion."
},
"PassRole" : {
"type": "IAMRoleName",
"collection": false,
"description": "Choose an IAM role to be used in running the job/crawler"
},
"TargetDatabase": {
"type": "String",
"collection" : false,
"description": "Choose a database in the Data Catalog."
},
"TargetS3Location": {
"type": "S3Uri",
"collection" : false,
"description": "Choose an Amazon S3 output path: ex:s3:///."
},
"ScriptsBucket": {
"type": "S3Bucket",
"collection": false,
"description": "Provide an S3 bucket name(in the same AWS Region) to store the scripts."
}
}
}
```
Das folgende Skript in der Datei `Conversion.py` ist das hochgeladene ETL-Skript. Beachten Sie, dass das Partitionierungsschema während der Konvertierung beibehalten wird.
```
import sys
from pyspark.sql.functions import *
from pyspark.context import SparkContext
from awsglue.transforms import *
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
import boto3
args = getResolvedOptions(sys.argv, [
'JOB_NAME',
'region_name',
'database_name',
'table_prefix',
'output_path'])
databaseName = args['database_name']
tablePrefix = args['table_prefix']
outputPath = args['output_path']
glue = boto3.client('glue', region_name=args['region_name'])
glue_context = GlueContext(SparkContext.getOrCreate())
spark = glue_context.spark_session
job = Job(glue_context)
job.init(args['JOB_NAME'], args)
def get_tables(database_name, table_prefix):
tables = []
paginator = glue.get_paginator('get_tables')
for page in paginator.paginate(DatabaseName=database_name, Expression=table_prefix+"*"):
tables.extend(page['TableList'])
return tables
for table in get_tables(databaseName, tablePrefix):
tableName = table['Name']
partitionList = table['PartitionKeys']
partitionKeys = []
for partition in partitionList:
partitionKeys.append(partition['Name'])
# Create DynamicFrame from Catalog
dyf = glue_context.create_dynamic_frame.from_catalog(
name_space=databaseName,
table_name=tableName,
additional_options={
'useS3ListImplementation': True
},
transformation_ctx='dyf'
)
# Resolve choice type with make_struct
dyf = ResolveChoice.apply(
frame=dyf,
choice='make_struct',
transformation_ctx='resolvechoice_' + tableName
)
# Drop null fields
dyf = DropNullFields.apply(
frame=dyf,
transformation_ctx="dropnullfields_" + tableName
)
# Write DynamicFrame to S3 in glueparquet
sink = glue_context.getSink(
connection_type="s3",
path=outputPath,
enableUpdateCatalog=True,
partitionKeys=partitionKeys
)
sink.setFormat("glueparquet")
sink.setCatalogInfo(
catalogDatabase=databaseName,
catalogTableName=tableName[len(tablePrefix):]
)
sink.writeFrame(dyf)
job.commit()
```
**Anmerkung**
Nur zwei Amazon-S3-Pfade können als Eingabe für den Beispiel-Blueprint bereitgestellt werden. Das liegt daran, dass AWS Glue-Auslöser auf das Aufrufen von nur zwei Crawler-Aktionen beschränkt sind.
# Testen eines Blueprints
Während Sie Ihren Code entwickeln, sollten Sie lokale Tests durchführen, um zu überprüfen, ob das Workflow-Layout korrekt ist.
Lokale Tests generieren keine AWS Glue-Aufträge, -Crawler oder -Auslöser. Stattdessen führen Sie das Layoutskript lokal aus und verwenden die Methoden `to_json()` und`validate()`, um Objekte zu drucken und Fehler zu finden. Diese Methoden sind in allen drei Klassen verfügbar, die in den Bibliotheken definiert sind.
Es gibt zwei Möglichkeiten zur Handhabung der Argumente `user_params` und `system_params`, die AWS Glue an Ihre Layoutfunktion übergibt. Ihr Testbench-Code kann ein Wörterbuch mit Beispiel-Blueprint-Parameterwerten erstellen und dieses als `user_params`-Argument an die Layoutfunktion übergeben. Sie können auch die Verweise auf `user_params` entfernen und durch hartcodierte Zeichenfolgen ersetzen.
Wenn Ihr Code die Eigenschaften `region` und `accountId` im Argument `system_params` verwendet, können Sie Ihr eigenes Wörterbuch für `system_params` übergeben.
**Blueprint testen**
1. Starten Sie einen Python-Interpreter in einem Verzeichnis mit den Bibliotheken oder laden Sie die Blueprint-Dateien und die bereitgestellten Bibliotheken in Ihre bevorzugte integrierte Entwicklungsumgebung (IDE).
1. Stellen Sie sicher, dass Ihr Code die bereitgestellten Bibliotheken importiert.
1. Fügen Sie Code zu Ihrer Layoutfunktion hinzu, um `validate()` oder `to_json()` für eine beliebige Entität oder das `Workflow`-Objekt aufzurufen. Wenn Ihr Code beispielsweise ein `Crawler`-Objekt namens `mycrawler` erstellt, können Sie `validate()` wie folgt aufrufen.
```
mycrawler.validate()
```
Sie können `mycrawler` wie folgt drucken:
```
print(mycrawler.to_json())
```
Wenn Sie `to_json` für ein Objekt aufrufen, müssen Sie `validate()` nicht auch aufrufen, da ` to_json()` `validate()` aufruft.
Am nützlichsten ist es, diese Methoden für das Workflow-Objekt aufzurufen. Angenommen, das Skript benennt das Workflowobjekt mit `my_workflow`, validieren und drucken Sie das Workflow-Objekt wie folgt.
```
print(my_workflow.to_json())
```
Weitere Informationen zu `to_json()` und `validate()` finden Sie unter [Klassenmethoden](developing-blueprints-code-classes.md#developing-blueprints-code-methods).
Sie können auch `pprint` importieren und das Workflow-Objekt im Schöndruck drucken, wie im Beispiel weiter unten in diesem Abschnitt gezeigt.
1. Führen Sie den Code aus, beheben Sie Fehler und entfernen Sie schließlich alle Aufrufe von `validate()` oder `to_json()`.
**Example**
Das folgende Beispiel zeigt, wie ein Wörterbuch mit Blueprint-Beispielparametern erstellt und als `user_params`-Argument an die Layoutfunktion `generate_compaction_workflow` übergeben wird. Außerdem wird gezeigt, wie das generierte Workflow-Objekt im Schöndruck gedruckt wird.
```
from pprint import pprint
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
USER_PARAMS = {"WorkflowName": "compaction_workflow",
"ScriptLocation": "s3://amzn-s3-demo-bucket/scripts/threaded-compaction.py",
"PassRole": "arn:aws:iam::111122223333:role/GlueRole-ETL",
"DatabaseName": "cloudtrial",
"TableName": "ct_cloudtrail",
"CoalesceFactor": 4,
"MaxThreadWorkers": 200}
def generate_compaction_workflow(user_params: dict, system_params: dict) -> Workflow:
compaction_job = Job(Name=f"{user_params['WorkflowName']}_etl_job",
Command={"Name": "glueetl",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "3"},
Role="arn:aws:iam::111122223333:role/AWSGlueServiceRoleDefault",
DefaultArguments={"DatabaseName": user_params['DatabaseName'],
"TableName": user_params['TableName'],
"CoalesceFactor": user_params['CoalesceFactor'],
"max_thread_workers": user_params['MaxThreadWorkers']})
catalog_target = {"CatalogTargets": [{"DatabaseName": user_params['DatabaseName'], "Tables": [user_params['TableName']]}]}
compacted_files_crawler = Crawler(Name=f"{user_params['WorkflowName']}_post_crawl",
Targets = catalog_target,
Role=user_params['PassRole'],
DependsOn={compaction_job: "SUCCEEDED"},
WaitForDependencies="AND",
SchemaChangePolicy={"DeleteBehavior": "LOG"})
compaction_workflow = Workflow(Name=user_params['WorkflowName'],
Entities=Entities(Jobs=[compaction_job],
Crawlers=[compacted_files_crawler]))
return compaction_workflow
generated = generate_compaction_workflow(user_params=USER_PARAMS, system_params={})
gen_dict = generated.to_json()
pprint(gen_dict)
```
# Veröffentlichen eines Blueprints
Nachdem Sie einen Blueprint entwickelt haben, müssen Sie ihn in Amazon S3 hochladen. Sie müssen Schreibberechtigungen für den Amazon-S3-Bucket haben, der zum Veröffentlichen des Blueprints verwendet wird. Sie müssen auch sicherstellen, dass der AWS Glue-Administrator, der den Blueprint registrieren wird, über Lesezugriff auf den Amazon-S3-Bucket verfügt. Die vorgeschlagenen AWS Identity and Access Management (IAM-) Berechtigungsrichtlinien für Personas und Rollen für AWS Glue Blueprints finden Sie unter. [Berechtigungen für Personas und Rollen für AWS Glue-Blueprints](blueprints-personas-permissions.md)
**Blueprint veröffentlichen**
1. Erstellen Sie die erforderlichen Skripte und Ressourcen und die Blueprint-Konfigurationsdatei.
1. Fügen Sie alle Dateien zu einem ZIP-Archiv hinzu und laden Sie die ZIP-Datei in Amazon S3 hoch. Verwenden Sie einen S3 Bucket, der sich in der Region befindet, in der Benutzer den Blueprint registrieren und ausführen werden.
Sie können über die Befehlszeile mit dem folgenden Befehl eine ZIP-Datei erstellen.
```
zip -r folder.zip folder
```
1. Fügen Sie eine Bucket-Richtlinie hinzu, die dem gewünschten Konto Leseberechtigungen gewährt. AWS Im Folgenden finden Sie eine Beispielrichtlinie.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::my-blueprints/*"
}
]
}
```
------
1. Gewähren Sie dem AWS Glue-Administrator oder der Person, die Blueprints registrieren wird, die IAM-Berechtigung `s3:GetObject` für den Amazon-S3-Bucket. Eine Beispielrichtlinie zur Erteilung an Administratoren finden Sie unter [AWS Glue-Administratorberechtigungen für Blueprints](blueprints-personas-permissions.md#bp-persona-admin).
Nachdem Sie das lokale Testen Ihres Blueprints abgeschlossen haben, könnten Sie einen Blueprint auch in AWS Glue testen. Um einen Blueprint in AWS Glue zu testen, muss er registriert sein. Sie können mithilfe von IAM-Autorisierung oder durch Verwendung separater Testkonten einschränken, wer den registrierten Blueprint sehen kann.
**Weitere Informationen finden Sie auch unter:**
[Registrieren eines Blueprints in AWS Glue](registering-blueprints.md)
# Referenz zu AWS Glue-Blueprint-Klassen
Die Bibliotheken für AWS Glue-Blueprints definieren drei Klassen, die Sie in Ihrem Workflow-Layoutskript verwenden: `Job`, `Crawler` und `Workflow`.
**Topics**
+ [Auftragsklasse](#developing-blueprints-code-jobclass)
+ [Crawler-Klasse](#developing-blueprints-code-crawlerclass)
+ [Workflow-Klasse](#developing-blueprints-code-workflowclass)
+ [Klassenmethoden](#developing-blueprints-code-methods)
## Auftragsklasse
Die `Job`-Klasse repräsentiert einen AWS Glue-ETL-Auftrag.
**Obligatorische Konstruktor-Argumente**
Nachfolgend sind obligatorische Konstruktor-Argumente für die `Job`-Klasse aufgeführt.
| Argumentname | Typ | Description |
| --- | --- | --- |
| Name | str | Name, der dem Auftrag zugewiesen werden soll.AWS Glue fügt ein zufällig generiertes Suffix zum Namen hinzu, um den Auftrag von Aufträgen zu unterscheiden, die von anderen Blueprint-Durchläufen erstellt wurden. |
| Role | str | Amazon-Ressourcenname (ARN) der Rolle, die der Auftrag bei der Ausführung übernehmen soll. |
| Command | dict | Auftragsbefehl, wie in [JobCommand Struktur](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-JobCommand) in der API-Dokumentation angegeben. |
**Optionale Konstruktor-Argumente**
Nachfolgend sind optionale Konstruktor-Argumente für die `Job`-Klasse aufgeführt.
| Argumentname | Typ | Description |
| --- | --- | --- |
| DependsOn | dict | Liste der Workflow-Entitäten, von denen der Auftrag abhängt. Weitere Informationen finden Sie unter [Das DependsOn Argument verwenden](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Gibt an, ob der Auftrag warten soll, bis alle Entitäten, von denen er abhängig ist, vor der Ausführung abgeschlossen sind, oder bis irgendeine abgeschlossen ist. Weitere Informationen finden Sie unter [Verwenden des WaitForDependencies Arguments](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Lassen Sie das Argument weg, wenn der Auftrag nur von einer Entität abhängt. |
| (Auftragseigenschaften) | - | Alle Auftragseigenschaften, die unter [Auftrags-Struktur](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-Job) in der AWS Glue-API-Dokumentation aufgeführt sind (außer CreatedOn und LastModifiedOn). |
## Crawler-Klasse
Die `Crawler`-Klasse repräsentiert einen AWS Glue-Crawler.
**Obligatorische Konstruktor-Argumente**
Nachfolgend sind obligatorische Konstruktor-Argumente für die `Crawler`-Klasse aufgeführt.
| Argumentname | Typ | Description |
| --- | --- | --- |
| Name | str | Name, der dem Crawler zugewiesen werden soll.AWS Glue fügt ein zufällig generiertes Suffix zum Namen hinzu, um den Crawler von Crawlern zu unterscheiden, die von anderen Blueprint-Durchläufen erstellt wurden. |
| Role | str | ARN der Rolle, die der Crawler während der Ausführung übernehmen soll. |
| Targets | dict | Sammlung von Zielen für das Crawlen. Targets-Klassen-Konstruktor-Argumente sind in der [CrawlerTargets Struktur](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-CrawlerTargets) in der API-Dokumentation definiert. Alle Targets-Konstruktor-Argumente sind optional, Sie müssen jedoch mindestens eines übergeben. |
**Optionale Konstruktor-Argumente**
Nachfolgend sind optionale Konstruktor-Argumente für die `Crawler`-Klasse aufgeführt.
| Argumentname | Typ | Description |
| --- | --- | --- |
| DependsOn | dict | Liste der Workflow-Entitäten, von denen der Crawler abhängt. Weitere Informationen finden Sie unter [Das DependsOn Argument verwenden](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Gibt an, ob der Crawler warten soll, bis alle Entitäten, von denen er abhängig ist, vor der Ausführung abgeschlossen sind, oder bis irgendeine abgeschlossen ist. Weitere Informationen finden Sie unter [Verwenden des WaitForDependencies Arguments](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Lassen Sie das Argument weg, wenn der Crawler nur von einer Entität abhängt. |
| (Crawler-Eigenschaften) | - | Alle Crawler-Eigenschaften, die unter [Crawler-Struktur](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-Crawler) in der AWS Glue-API-Dokumentation aufgeführt sind, mit den folgenden Ausnahmen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/developing-blueprints-code-classes.html) |
## Workflow-Klasse
Die `Workflow`-Klasse repräsentiert einen AWS Glue-Workflow. Das Workflow-Layout-Skript gibt ein `Workflow`-Objekt aus. AWS Glue erstellt einen Workflow basierend auf diesem Objekt.
**Obligatorische Konstruktor-Argumente**
Nachfolgend sind obligatorische Konstruktor-Argumente für die `Workflow`-Klasse aufgeführt.
| Argumentname | Typ | Description |
| --- | --- | --- |
| Name | str | Name, der dem Workflow zugewiesen werden soll. |
| Entities | Entities | Eine Sammlung von Entitäten (Aufträgen und Crawlern), die im Workflow enthalten sein sollen. Der Entities-Klassen-Konstruktor akzeptiert ein Jobs-Argument, bei dem es sich um eine Liste von Job-Objekten handelt, und ein Crawlers-Argument, bei dem es sich um eine Liste von Crawler-Objekten handelt. |
**Optionale Konstruktor-Argumente**
Nachfolgend sind optionale Konstruktor-Argumente für die `Workflow`-Klasse aufgeführt.
| Argumentname | Typ | Description |
| --- | --- | --- |
| Description | str | Siehe [Workflow-Struktur](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| DefaultRunProperties | dict | Siehe [Workflow-Struktur](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| OnSchedule | str | Ein cron-Ausdruck. |
## Klassenmethoden
Alle drei Klassen umfassen die folgenden Methoden.
**validate()**
Validiert die Eigenschaften des Objekts und gibt eine Meldung aus und wird beendet, wenn Fehler gefunden werden. Generiert keine Ausgabe, wenn keine Fehler vorliegen. Ruft sich für die `Workflow`-Klasse selbst für jede Entität im Workflow auf.
**to\$1json()**
Serialisiert das Objekt in JSON. Ruft auch `validate()` auf. Für die `Workflow`-Klasse enthält das JSON-Objekt Auftrags- und Crawler-Listen sowie eine Liste von Auslösern, die von den Auftrags- und Crawler-Abhängigkeitsspezifikationen generiert werden.
# Blueprint-Beispiele
Im [AWS Glue-Blueprint-Github-Repository](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/samples) ist eine Reihe von Blueprint-Beispielprojekten verfügbar. Diese Beispiele dienen nur als Referenz und sind nicht für die Produktion bestimmt.
Die Titel der Beispielprojekte lauten:
+ Compaction (Komprimierung): Dieser Blueprint erstellt einen Auftrag, der Eingabedateien basierend auf der gewünschten Dateigröße in größere Blöcke komprimiert.
+ Conversion (Konvertierung): Dieser Blueprint konvertiert Eingabedateien in verschiedenen Standard-Dateiformaten ins Apache-Parquet-Format, das für analytische Workloads optimiert ist.
+ Crawling Amazon S3 locations (Crawling von Amazon-S3-Speicherorten): Dieser Blueprint durchsucht mehrere Amazon-S3-Speicherorte, um Metadatentabellen zum Data Catalog hinzuzufügen.
+ Benutzerdefinierte Verbindung zum Datenkatalog: Dieser Blueprint greift mithilfe AWS Glue benutzerdefinierter Konnektoren auf Datenspeicher zu, liest die Datensätze und füllt die Tabellendefinitionen im AWS Glue-Datenkatalog auf der Grundlage des Datensatzschemas.
+ Encoding (Codierung): Dieser Blueprint konvertiert Nicht-UTF-Dateien in UTF-codierte Dateien.
+ Partitioning (Partitionierung): Dieser Blueprint erstellt einen Partitionierungsauftrag, der Ausgabedateien basierend auf bestimmten Partitionsschlüsseln in Partitionen platziert.
+ Importing Amazon S3 data into a DynamoDB table (Importieren von Amazon-S3-Daten in eine DynamoDB-Tabelle): Dieser Blueprint importiert Daten aus Amazon S3 in eine DynamoDB-Tabelle.
+ Standardtabelle zur Steuerung: Dieser Blueprint importiert eine AWS Glue Data Catalog-Tabelle in eine Lake Formation-Tabelle.
# Registrieren eines Blueprints in AWS Glue
Nachdem der AWS Glue-Entwickler den Blueprint codiert und ein ZIP-Archiv in Amazon Simple Storage Service (Amazon S3) hochgeladen hat, muss der Blueprint von einem AWS Glue-Administrator registriert werden. Die Registrierung sorgt dafür, dass der Blueprint verwendet werden kann.
Wenn Sie einen Blueprint registrieren, kopiert AWS Glue das Blueprint-Archiv an einen reservierten Amazon-S3-Speicherort. Anschließend können Sie das Archiv aus dem Upload-Speicherort löschen.
Um einen Blueprint zu registrieren, benötigen Sie Leseberechtigungen für den Amazon-S3-Speicherort, an dem sich das hochgeladene Archiv befindet. Sie benötigen auch die AWS Identity and Access Management (IAM-) Genehmigung`glue:CreateBlueprint`. Die vorgeschlagenen Berechtigungen für einen AWS Glue-Administrator, der Blueprints registrieren, anzeigen und verwalten muss, finden Sie unter [AWS Glue-Administratorberechtigungen für Blueprints](blueprints-personas-permissions.md#bp-persona-admin).
Sie können einen Blueprint mit der AWS Glue-Konsole, der AWS Glue-API oder AWS Command Line Interface (AWS CLI) registrieren.
**Einen Blueprint registrieren (Konsole)**
1. Stellen Sie sicher, dass Sie Leseberechtigungen (`s3:GetObject`) für das Blueprint-ZIP-Archiv in Amazon S3 haben.
1. Öffnen Sie die AWS Glue-Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Melden Sie sich als Benutzer mit Berechtigungen zum Registrieren eines Blueprints an. Wechseln Sie zur AWS -Region des Amazon-S3-Buckets, der das Blueprint-ZIP-Archiv enthält.
1. Wählen Sie im Navigationsbereich die Option **Blueprints** aus. Wählen Sie dann auf der Seite **Blueprints** die Option **Add blueprint (Blueprint hinzufügen** aus.
1. Geben Sie einen Namen und optional eine Beschreibung ein.
1. Geben Sie unter **ZIP archive location (S3) (Speicherort des ZIP-Archivs (S3))** den Amazon-S3- Pfad des hochgeladenen Blueprint-ZIP-Archivs ein. Fügen Sie dabei den Namen der Archivdatei hinzu und beginnen Sie den Pfad mit `s3://`.
1. (Optional) Fügen Sie einen oder mehrere Tags hinzu.
1. Wählen Sie **Add blueprint (Blueprint hinzufügen)** aus.
Die Seite **Blueprints** wird wieder geöffnet und zeigt den Blueprint-Status `CREATING` an. Wählen Sie die Schaltfläche „Refresh“ (Aktualisieren) aus, bis sich der Status in `ACTIVE` oder `FAILED` ändert.
1. Wenn der Status `FAILED` lautet, wählen Sie den Blueprint und dann im Menü **Actions (Aktionen)** die Option **View (Anzeigen)** aus.
Auf der Detailseite wird der Grund für den Fehlschlag angezeigt. Wenn die Fehlermeldung „Unable to access object at location...“ oder „Access denied on object at location...“ lautet, überprüfen Sie die folgenden Anforderungen:
+ Das Benutzerkonto, mit dem Sie angemeldet sind, muss Leseberechtigungen für das Blueprint-ZIP-Archiv in Amazon S3 haben.
+ Der Amazon S3 S3-Bucket, der das ZIP-Archiv enthält, muss über eine Bucket-Richtlinie verfügen, die Ihrer AWS Konto-ID Leseberechtigungen für das Objekt gewährt. Weitere Informationen finden Sie unter [Entwickeln von Blueprints in AWS Glue](developing-blueprints.md).
+ Der verwendete Amazon-S3-Bucket muss sich in derselben Region befinden, bei der Sie in der Konsole angemeldet sind.
1. Stellen Sie sicher, dass Datenanalysten die nötigen Berechtigungen für den Blueprint haben.
Die vorgeschlagene IAM-Richtlinie für Datenanalysten finden Sie unter [Datenanalystenberechtigungen für Blueprints](blueprints-personas-permissions.md#bp-persona-analyst). Diese Richtlinie gewährt `glue:GetBlueprint` für jede Ressource. Sollte Ihre Richtlinie auf Ressourcenebene differenzierter sein, erteilen Sie Datenanalysten Berechtigungen für diese neu erstellte Ressource.
**Um einen Blueprint (AWS CLI) zu registrieren**
1. Geben Sie den folgenden Befehl ein.
```
aws glue create-blueprint --name [--description ] --blueprint-location s3:///
```
1. Geben Sie zur Prüfung des Blueprint-Status den folgenden Befehl ein. Wiederholen Sie den Befehl, bis sich der Status zu `ACTIVE` oder `FAILED` ändert.
```
aws glue get-blueprint --name
```
Wenn der Status `FAILED` lautet und die Fehlermeldung „Unable to access object at location...“ oder „Access denied on object at location...“ angezeigt wird, überprüfen Sie die folgenden Anforderungen:
+ Das Benutzerkonto, mit dem Sie angemeldet sind, muss Leseberechtigungen für das Blueprint-ZIP-Archiv in Amazon S3 haben.
+ Der Amazon S3 S3-Bucket, der das ZIP-Archiv enthält, muss über eine Bucket-Richtlinie verfügen, die Ihrer AWS Konto-ID Leseberechtigungen für das Objekt gewährt. Weitere Informationen finden Sie unter [Veröffentlichen eines Blueprints](developing-blueprints-publishing.md).
+ Der verwendete Amazon-S3-Bucket muss sich in derselben Region befinden, bei der Sie in der Konsole angemeldet sind.
**Weitere Informationen finden Sie auch unter:**
[Übersicht über Blueprints in AWS Glue](blueprints-overview.md)
# Anzeigen von Blueprints in AWS Glue
Rufen Sie einen Blueprint auf, um die Beschreibung, den Status und die Parameterspezifikationen zu überprüfen und das Blueprint-ZIP-Archiv herunterzuladen.
Sie können einen Blueprint mit der AWS Glue-Konsole, der AWS Glue-API oder AWS Command Line Interface (AWS CLI) aufrufen.
**Einen Blueprint aufrufen (Konsole)**
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 die Option **Blueprints** aus.
1. Wählen Sie auf der Seite **Blueprints** einen Blueprint aus. Wählen Sie dann im Menü **Actions (Aktionen)** die Option **View (Anzeigen)** aus.
**So zeigen Sie einen Blueprint an (AWS CLI)**
+ Geben Sie den folgenden Befehl ein, um nur den Namen, die Beschreibung und den Status des Blueprints anzuzeigen. **Ersetzen Sie ihn durch den Namen des anzuzeigenden Blueprints.
```
aws glue get-blueprint --name
```
Die Befehlsausgabe sieht ungefähr wie folgt aus.
```
{
"Blueprint": {
"Name": "myDemoBP",
"CreatedOn": 1587414516.92,
"LastModifiedOn": 1587428838.671,
"BlueprintLocation": "s3://amzn-s3-demo-bucket1/demo/DemoBlueprintProject.zip",
"Status": "ACTIVE"
}
}
```
Geben Sie den folgenden Befehl ein, um auch die Parameterspezifikationen aufzurufen.
```
aws glue get-blueprint --name --include-parameter-spec
```
Die Befehlsausgabe sieht ungefähr wie folgt aus.
```
{
"Blueprint": {
"Name": "myDemoBP",
"CreatedOn": 1587414516.92,
"LastModifiedOn": 1587428838.671,
"ParameterSpec": "{\"WorkflowName\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"PassRole\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"DynamoDBTableName\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"ScriptLocation\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null}}",
"BlueprintLocation": "s3://awsexamplebucket1/demo/DemoBlueprintProject.zip",
"Status": "ACTIVE"
}
}
```
Fügen Sie das Argument `--include-blueprint` hinzu, um eine URL in die Ausgabe aufzunehmen, die Sie in Ihren Browser einfügen können, um das von AWS Glue gespeicherte Blueprint-ZIP-Archiv herunterzuladen.
**Weitere Informationen finden Sie auch unter:**
[Übersicht über Blueprints in AWS Glue](blueprints-overview.md)
# Aktualisieren eines Blueprints in AWS Glue
Sie können einen Blueprint aktualisieren, wenn ein überarbeitetes Layoutskript, ein überarbeiteter Satz von Blueprint-Parametern oder überarbeitete zugehörige Dateien vorliegen. Beim Aktualisieren eines Blueprints wird eine neue Version erstellt.
Das Aktualisieren eines Blueprints wirkt sich nicht auf bestehende Workflows aus, die mit dem Blueprint erstellt wurden.
Sie können einen Blueprint mit der AWS Glue-Konsole, der AWS Glue-API oder AWS Command Line Interface (AWS CLI) aktualisieren.
Beim folgenden Verfahren wird davon ausgegangen, dass der AWS Glue-Entwickler ein aktualisiertes Blueprint-ZIP-Archiv erstellt und in Amazon S3 hochgeladen hat.
**Einen Blueprint aktualisieren (Konsole)**
1. Stellen Sie sicher, dass Sie Leseberechtigungen (`s3:GetObject`) für das Blueprint-ZIP-Archiv in Amazon S3 haben.
1. Öffnen Sie die AWS Glue-Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Melden Sie sich als Benutzer mit Berechtigungen zum Aktualisieren eines Blueprints an. Wechseln Sie zur AWS -Region des Amazon-S3-Buckets, der das Blueprint-ZIP-Archiv enthält.
1. Wählen Sie im Navigationsbereich die Option **Blueprints** aus.
1. Wählen Sie auf der Seite **Blueprints** einen Blueprint aus und gehen Sie dann im Menü **Actions (Aktionen)** auf **Edit (Bearbeiten)**.
1. Ändern Sie auf der Seite **Edit a blueprint (Blueprint bearbeiten)** die **Description (Beschreibung)** oder die **ZIP archive location (S3) (Speicherort des ZIP-Archivs (S3))**. Achten Sie darauf, den Archivdateinamen in den Pfad einzugeben.
1. Wählen Sie **Speichern**.
Die Seite **Blueprints** wird wieder geöffnet und zeigt den Blueprint-Status `UPDATING` an. Wählen Sie die Schaltfläche „Refresh“ (Aktualisieren) aus, bis sich der Status in `ACTIVE` oder `FAILED` ändert.
1. Wenn der Status `FAILED` lautet, wählen Sie den Blueprint und dann im Menü **Actions (Aktionen)** die Option **View (Anzeigen)** aus.
Auf der Detailseite wird der Grund für den Fehlschlag angezeigt. Wenn die Fehlermeldung „Unable to access object at location...“ oder „Access denied on object at location...“ lautet, überprüfen Sie die folgenden Anforderungen:
+ Das Benutzerkonto, mit dem Sie angemeldet sind, muss Leseberechtigungen für das Blueprint-ZIP-Archiv in Amazon S3 haben.
+ Der Amazon S3 S3-Bucket, der das ZIP-Archiv enthält, muss über eine Bucket-Richtlinie verfügen, die Ihrer AWS Konto-ID Leseberechtigungen für das Objekt gewährt. Weitere Informationen finden Sie unter [Veröffentlichen eines Blueprints](developing-blueprints-publishing.md).
+ Der verwendete Amazon-S3-Bucket muss sich in derselben Region befinden, bei der Sie in der Konsole angemeldet sind.
**Anmerkung**
Sollte die Aktualisierung fehlschlagen, wird bei der nächsten Blueprint-Ausführung die neueste Version des Blueprints verwendet, die erfolgreich registriert oder aktualisiert wurde.
**Einen Blueprint aktualisieren (AWS CLI)**
1. Geben Sie den folgenden Befehl ein.
```
aws glue update-blueprint --name [--description ] --blueprint-location s3:///
```
1. Geben Sie zur Prüfung des Blueprint-Status den folgenden Befehl ein. Wiederholen Sie den Befehl, bis sich der Status zu `ACTIVE` oder `FAILED` ändert.
```
aws glue get-blueprint --name
```
Wenn der Status `FAILED` lautet und die Fehlermeldung „Unable to access object at location...“ oder „Access denied on object at location...“ angezeigt wird, überprüfen Sie die folgenden Anforderungen:
+ Das Benutzerkonto, mit dem Sie angemeldet sind, muss Leseberechtigungen für das Blueprint-ZIP-Archiv in Amazon S3 haben.
+ Der Amazon S3 S3-Bucket, der das ZIP-Archiv enthält, muss über eine Bucket-Richtlinie verfügen, die Ihrer AWS Konto-ID Leseberechtigungen für das Objekt gewährt. Weitere Informationen finden Sie unter [Veröffentlichen eines Blueprints](developing-blueprints-publishing.md).
+ Der verwendete Amazon-S3-Bucket muss sich in derselben Region befinden, bei der Sie in der Konsole angemeldet sind.
**Weitere Informationen finden Sie auch unter**
[Übersicht über Blueprints in AWS Glue](blueprints-overview.md)
# Erstellen eines Workflows aus einem Blueprint in AWS Glue
Sie können einen AWS Glue-Workflow manuell erstellen, indem Sie die Komponenten einzeln hinzufügen, oder Sie erstellen einen Workflow aus einem AWS Glue-[Blueprint](blueprints-overview.md). AWS Glue beinhaltet Blueprints für gewöhnliche Nutzerfälle. Ihre AWS Glue-Entwickler können zusätzliche Blueprints erstellen.
**Wichtig**
Beschränken Sie die Gesamtzahl der Aufträge, Crawler und Trigger innerhalb eines Workflows auf 100 oder weniger. Wenn Sie mehr als 100 einschließen, werden möglicherweise Fehler angezeigt, wenn Sie versuchen, Workflow-Läufe fortzusetzen oder zu beenden.
Mit einem Blueprint als Ausgangspunkt können Sie schnell einen Workflow für einen bestimmten Anwendungsfall basierend auf dem im Blueprint definierten generalisierten Anwendungsfall generieren. Sie definieren den spezifischen Anwendungsfall, indem Sie Werte für die Blueprint-Parameter angeben. Ein Blueprint, der einen Datensatz partitioniert, könnte beispielsweise die Amazon-S3-Quell- und Zielpfade als Parameter enthalten.
AWS Glue erstellt einen Workflow aus einem Blueprint durch *Ausführen* des Blueprints. Im ausgeführten Blueprint werden die angegebenen Parameterwerte gespeichert und der Fortschritt und das Ergebnis der Erstellung des Workflows und seiner Komponenten festgehalten. Bei der Problembehandlung eines Workflows können Sie die Blueprint-Ausführung anzeigen, um die Parameterwerte zu ermitteln, die zum Erstellen eines Workflows verwendet wurden.
Zum Erstellen und Anzeigen von Workflows benötigen Sie bestimmte IAM-Berechtigungen. Einen Vorschlag für eine IAM-Richtlinie finden Sie unter [Datenanalystenberechtigungen für Blueprints](blueprints-personas-permissions.md#bp-persona-analyst).
Mit der AWS Glue-Konsole, AWS Glue-API oder AWS Command Line Interface (AWS CLI) können Sie einen Workflow aus einem Blueprint aktualisieren.
**Einen Workflow aus einem Blueprint erstellen (Konsole)**
1. Öffnen Sie die AWS Glue-Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Melden Sie sich als Benutzer mit den Berechtigungen zum Erstellen eines Workflows an.
1. Wählen Sie im Navigationsbereich die Option **Blueprints** aus.
1. Wählen Sie einen Blueprint aus und dann auf der Registerkarte **Actions (Aktionen)** die Option **Create workflow (Workflow erstellen)**.
1. Geben Sie auf der Seite **Create a workflow from (Einen Workflow aus erstellen)** folgende Informationen ein:
**Blueprint-Parameter**
Diese variieren je nach Blueprint-Design. Bei Fragen zu den Parametern wenden Sie sich an den Entwickler. Blueprints enthalten in der Regel einen Parameter für den Workflow-Namen.
**IAM role (IAM-Rolle)**
Die Rolle, die AWS Glue übernimmt, um den Workflow und die Workflow-Komponenten zu erstellen. Die Rolle muss über Berechtigungen zum Erstellen und Löschen von Workflows, Aufträgen, Crawlern und Auslösern verfügen. Einen Vorschlag für eine Richtlinie für die Rolle finden Sie unter [Berechtigungen für Blueprint-Rollen](blueprints-personas-permissions.md#blueprints-role-permissions).
1. Wählen Sie **Absenden** aus.
Die Seite **Blueprint Details (Blueprint-Details)** mit einer Liste der Blueprint-Ausführungen wird angezeigt.
1. Überprüfen Sie in der Liste der Blueprint-Ausführungen den obersten Eintrag auf den Status der Workflow-Erstellung.
Der ursprüngliche Status ist `RUNNING`. Wählen Sie die Schaltfläche „Refresh“ (Aktualisieren) aus, bis sich der Status in `SUCCEEDED` oder `FAILED` ändert.
1. Führen Sie eine der folgenden Aktionen aus:
+ Wenn der Abschlussstatus `SUCCEEDED` ist, können Sie die Seite **Workflows** öffnen, den neu erstellten Workflow auswählen und ihn ausführen. Bevor Sie den Workflow ausführen, können Sie das Designdiagramm überprüfen.
+ Wenn der Abschlussstatus `FAILED` ist, wählen Sie die Blueprint-Ausführung und dann im Menü **Actions (Aktionen)** die Option **View (Anzeigen)** aus, um die Fehlermeldung anzuzeigen.
Weitere Informationen zu Workflows und Blueprints finden Sie in den folgenden Themen.
+ [Übersicht über Workflows in AWS Glue](workflows_overview.md)
+ [Aktualisieren eines Blueprints in AWS Glue](updating_blueprints.md)
+ [Manuelles Erstellen und Aufbauen eines Workflows in AWS Glue](creating_running_workflows.md)
# Anzeigen von Blueprint-Ausführungen in AWS Glue
Rufen Sie eine Blueprint-Ausführung auf, um die folgenden Informationen anzuzeigen:
+ den Namen des erstellten Workflows
+ Blueprint-Parameterwerte, die zum Erstellen des Workflows verwendet wurden.
+ den Status der Workflow-Erstellung
Sie können eine Blueprint-Ausführung mit der AWS Glue-Konsole, der AWS Glue-API oder AWS Command Line Interface (AWS CLI) aufrufen.
**Eine Blueprint-Ausführung aufrufen (Konsole)**
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 die Option **Blueprints** aus.
1. Wählen Sie auf der Seite **Blueprints** einen Blueprint aus. Wählen Sie dann im Menü **Actions (Aktionen)** die Option **View (Anzeigen)** aus.
1. Wählen Sie unten auf der Seite **Blueprint Details (Blueprint-Details)** eine Blueprint-Ausführung aus und gehen Sie im Menü **Actions (Aktionen)** auf **View (Anzeigen)**.
**Eine Blueprint-Ausführung aufrufen (AWS CLI)**
+ Geben Sie den folgenden Befehl ein. **Ersetzen Sie es durch den Namen des Blueprints. Ersetzen Sie es ** durch die Blueprint-Run-ID.
```
aws glue get-blueprint-run --blueprint-name --run-id
```
**Weitere Informationen finden Sie auch unter:**
[Übersicht über Blueprints in AWS Glue](blueprints-overview.md)