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.
# 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)