

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.

# Streaming-ETL-Aufträge in AWS Glue
<a name="add-job-streaming"></a>

Sie können Streaming-Aufträge für ETL-Aufträge (Extract, Transform, Load) erstellen, die kontinuierlich ausgeführt werden und Daten aus Streaming-Quellen wie Amazon Kinesis Data Streams, Apache Kafka und Amazon Managed Streaming für Apache Kafka (Amazon MSK) konsumieren. Die Aufträge bereinigen und transformieren die Daten und laden die Ergebnisse dann in Amazon-S3-Data-Lakes oder JDBC-Datenspeicher.

Darüber hinaus können Sie Daten zu Amazon Kinesis Data Streams erstellen. Diese Funktion ist nur beim Schreiben von AWS Glue Skripten verfügbar. Weitere Informationen finden Sie unter [Kinesis-Verbindungen](aws-glue-programming-etl-connect-kinesis-home.md). 

Standardmäßig verarbeitet und schreibt AWS Glue Daten in 100-Sekunden-Fenstern. Dadurch können Daten effizient verarbeitet und Aggregationen für Daten ausgeführt werden, die später als erwartet eintreffen. Sie können diese Fenstergröße ändern, um die Aktualität oder Aggregationsgenauigkeit zu erhöhen. AWS Glue-Streaming-Aufträge verwenden Checkpoints anstelle von Auftragslesezeichen, um die gelesenen Daten zu verfolgen.

**Anmerkung**  
AWS Glue rechnet Streaming-ETL-Aufträge, während der Ausführung stündlich ab.

In diesem Video werden die Kostenprobleme beim Streamen von ETL und die Funktionen zur Kosteneinsparung in AWS Glue beschrieben.

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/6ggTFOtfUxU/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/6ggTFOtfUxU)


Die Erstellung eines Streaming-ETL-Auftrags umfasst die folgenden Schritte:

1. Erstellen Sie für eine Apache-Kafka-Streaming-Quelle eine AWS Glue-Verbindung mit der Kafka-Quelle oder dem Amazon-MSK-Cluster.

1. Erstellen Sie manuell eine Data-Catalog-Tabelle für die Streaming-Quelle.

1. Erstellen Sie einen ETL-Auftrag für die Streaming-Datenquelle. Definieren Sie streamingspezifische Auftragseigenschaften und geben Sie Ihr eigenes Skript an oder ändern Sie optional das generierte Skript.

Weitere Informationen finden Sie unter [ETL einstreamen AWS Glue](components-overview.md#streaming-etl-intro).

Wenn Sie einen Streaming-ETL-Auftrag für Amazon Kinesis Data Streams erstellen, müssen Sie keineAWS Glue-Verbindung erstellen. Wenn jedoch eine Verbindung an den AWS Glue-Streaming-ETL-Auftrag angefügt ist, der Kinesis Data Streams als Quelle enthält, dann ist ein VPC-Endpunkt (Virtual Private Cloud) für Kinesis erforderlich. Weitere Informationen finden Sie unter [Erstellung eines Schnittstellenendpunkts](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) im *Benutzerhandbuch für Amazon VPC*. Wenn Sie einen Amazon-Kinesis-Data-Streams-Stream in einem anderen Konto angeben, müssen Sie die Rollen und Richtlinien einrichten, um den kontenübergreifenden Zugriff zu ermöglichen. Weitere Informationen finden Sie unter [Beispiel: Aus einem Kinesis Stream in einem anderen Konto lesen](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html).

AWS Glue-Streaming-ETL-Aufträge können komprimierte Daten automatisch erkennen, die Streaming-Daten transparent dekomprimieren, die üblichen Transformationen an der Eingangsquelle durchführen und in den Ausgabespeicher laden. 

AWS Glue unterstützt die automatische Dekomprimierung für die folgenden Komprimierungstypen angesichts des Eingabeformats:


| Komprimierungsart | Avro-Datei | Avro-Datum | JSON | CSV | Grok | 
| --- | --- | --- | --- | --- | --- | 
| BZIP2 | Ja | Ja | Ja | Ja | Ja | 
| GZIP | Nein | Ja | Ja | Ja | Ja | 
| SNAPPY | Ja (rohes Snappy) | Ja (gerahmtes Snappy) | Ja (gerahmtes Snappy) | Ja (gerahmtes Snappy) | Ja (gerahmtes Snappy) | 
| XZ | Ja | Ja | Ja | Ja | Ja | 
| ZSTD | Ja | Nein | Nein | Nein | Nein | 
| DEFLATE | Ja | Ja | Ja | Ja | Ja | 

**Topics**
+ [Erstellen einer AWS Glue-Verbindung für einen Apache-Kafka-Datenstrom](#create-conn-streaming)
+ [Erstellen einer Data-Catalog-Tabelle für eine Streaming-Quelle](#create-table-streaming)
+ [Hinweise und Einschränkungen für Avro-Streaming-Quellen](#streaming-avro-notes)
+ [Anwenden von Grok-Mustern auf Streaming-Quellen](#create-table-streaming-grok)
+ [Definieren von Auftragseigenschaften für einen Streaming-ETL-Auftrag](#create-job-streaming-properties)
+ [Hinweise zu und Einschränkungen für Streaming-ETL](#create-job-streaming-restrictions)

## Erstellen einer AWS Glue-Verbindung für einen Apache-Kafka-Datenstrom
<a name="create-conn-streaming"></a>

Um das Lesen aus einem Apache-Kafka-Stream zu ermöglichen, müssen Sie eine AWS Glue-Verbindung erstellen. 

**So erstellen Sie eine AWS Glue-Verbindung für eine Kafka-Quelle (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 **Data catalog** die Option **Connections (Verbindungen)** aus.

1. Wählen Sie **Add connection (Verbindung hinzufügen)** und geben Sie auf der Seite **Set up your connection’s properties (Einrichten der Verbindungseigenschaften)** einen Verbindungsnamen ein.
**Anmerkung**  
Weitere Informationen zum Angeben von Verbindungseigenschaften finden Sie unter [Eigenschaften der AWS Glue -Verbindung](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-connections).

1. Wählen Sie für **Verbindungstyp** den Eintrag **Kafka**.

1. Geben Sie für **Kafka-Bootstrap-Server URLs** den Host und die Portnummer für die Bootstrap-Broker für Ihren Amazon MSK-Cluster oder Apache Kafka-Cluster ein. Verwenden Sie nur TLS-Endpunkte (Transport Layer Security (TLS)) zum Herstellen der ersten Verbindung mit dem Kafka-Cluster. Nur–Text-Endpunkte werden nicht unterstützt.

   Im Folgenden finden Sie eine Beispielliste mit Host-Port-Nummerpaaren für einen Amazon-MSK-Cluster.

   ```
   myserver1.kafka.us-east-1.amazonaws.com:9094,myserver2.kafka.us-east-1.amazonaws.com:9094,
   myserver3.kafka.us-east-1.amazonaws.com:9094
   ```

   Weitere Informationen zum Abrufen der Bootstrap-Broker-Informationen finden Sie unter [Abrufen der Bootstrap Broker für einen Amazon-MSK-Cluster](https://docs.aws.amazon.com/msk/latest/developerguide/msk-get-bootstrap-brokers.html) im *Amazon Managed Streaming for Apache-Kafka-Entwicklerhandbuch*. 

1. Wenn Sie eine sichere Verbindung zur Kafka-Datenquelle wünschen, wählen Sie **SSL-Verbindung erforderlich** und geben für **Standort des privaten CA-Zertifikats von Kafka** einen gültigen Amazon S3 Pfad zu einem benutzerdefinierten SSL-Zertifikat ein.

   Für eine SSL-Verbindung zu selbstverwaltetem Kafka ist das benutzerdefinierte Zertifikat obligatorisch. Es ist optional für Amazon MSK.

   Weitere Informationen zur Angabe eines benutzerdefinierten Zertifikats für Kafka finden Sie unter [AWS Glue Eigenschaften der SSL-Verbindung](connection-properties.md#connection-properties-SSL).

1. Verwenden Sie AWS Glue Studio oder die AWS CLI, um eine Kafka-Client-Authentifizierungsmethode anzugeben. Um darauf zuzugreifen, AWS Glue Studio wählen Sie im **ETL-Menü** im linken Navigationsbereich **AWS Glue**aus.

   Weitere Informationen über Kafka-Client-Authentifizierungsmethoden finden Sie unter [AWS Glue-Kafka-Verbindungseigenschaften für die Client-Authentifizierung](#connection-properties-kafka-client-auth).

1. Geben Sie optional eine Beschreibung ein und wählen Sie dann **Next (Weiter)**.

1. Geben Sie für einen Amazon-MSK-Cluster die Virtual Private Cloud (VPC), das Subnetz und die Sicherheitsgruppe an. Für selbstverwaltetes Kafka sind die VPC-Informationen optional.

1. Klicken Sie auf **Next (Weiter)**, um alle Verbindungseigenschaften zu überprüfen, und wählen Sie dann **Finish (Abschließen)**.

Weitere Informationen zu AWS Glue-Verbindungen finden Sie unter [Herstellen einer Verbindung zu Daten](glue-connections.md).

### AWS Glue-Kafka-Verbindungseigenschaften für die Client-Authentifizierung
<a name="connection-properties-kafka-client-auth"></a>

**SASL/GSSAPI (Kerberos)-Authentifizierung**  
Wenn Sie diese Authentifizierungsmethode wählen, können Sie Kerberos-Eigenschaften angeben.

**Kerberos-Keytab**  
Wählen Sie den Speicherort der Keytab-Datei aus. Ein Keytab speichert Langzeitschlüssel für ein oder mehrere Prinzipale. Weitere Informationen finden Sie unter [MIT-Kerberos-Dokumentation: Keytab](https://web.mit.edu/kerberos/krb5-latest/doc/basic/keytab_def.html). 

**Kerberos krb5.conf-Datei**  
Wählen Sie die krb5.conf-Datei aus. Dies enthält den Standardbereich (ein logisches Netzwerk, ähnlich einer Domain, das eine Gruppe von Systemen unter demselben KDC definiert) und den Standort des KDC-Servers. Weitere Informationen finden Sie in der [MIT-Kerberos-Dokumentation: krb5.conf](https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html). 

**Kerberos-Prinzipal und Kerberos-Dienstname**  
Geben Sie den Kerberos-Prinzipal und den Dienstnamen ein. Weitere Informationen finden Sie unter [MIT Kerberos-Dokumentation: Kerberos-Prinzipal](https://web.mit.edu/kerberos/krb5-1.5/krb5-1.5.4/doc/krb5-user/What-is-a-Kerberos-Principal_003f.html). 

**SASL/SCRAM-SHA-512-Authentifizierung**  
 Wenn Sie diese Authentifizierungsmethode wählen, können Sie Anmeldeinformationen zur Authentifizierung angeben. 

**AWS Secrets Manager**  
Suchen Sie im Suchfeld nach Ihrem Token, indem Sie den Namen oder ARN eingeben. 

**Benutzername und Passwort des Anbieters direkt**  
Suchen Sie im Suchfeld nach Ihrem Token, indem Sie den Namen oder ARN eingeben. 

**SSL-Client-Authentifizierung**  
Wenn Sie diese Authentifizierungsmethode wählen, können Sie den Standort des Kafka-Client-Keystores auswählen, indem Sie Amazon S3 durchsuchen. Optional können Sie das Kennwort für den Kafka-Client-Keystore und das Kafka-Client-Schlüsselkennwort eingeben. 

**IAM-Authentifizierung**  
Diese Authentifizierungsmethode erfordert keine zusätzlichen Spezifikationen und ist nur anwendbar, wenn die Streaming-Quelle MSK Kafka ist. 

**SASL/PLAIN-Authentifizierung**  
Wenn Sie diese Authentifizierungsmethode wählen, können Sie Anmeldeinformationen zur Authentifizierung angeben. 

## Erstellen einer Data-Catalog-Tabelle für eine Streaming-Quelle
<a name="create-table-streaming"></a>

Eine Datenkatalogtabelle, die die Eigenschaften des Quelldatenstroms, einschließlich des Datenschemas, angibt, kann manuell für eine Streaming-Quelle erstellt werden. Diese Tabelle wird als Datenquelle für den Streaming-ETL-Auftrag verwendet. 

Wenn Sie das Schema der Daten im Quelldatenstrom nicht kennen, können Sie die Tabelle ohne Schema erstellen. Wenn Sie dann den Streaming-ETL-Auftrag erstellen, können Sie die AWS Glue-Schema-Erkennungsfunktion verwenden. AWS Glue ermittelt das Schema aus den Streaming-Daten.

Verwenden Sie die [AWS GlueKonsole](https://console.aws.amazon.com/glue/), die AWS Command Line Interface (AWS CLI) oder die AWS Glue API, um die Tabelle zu erstellen. Weitere Informationen zur manuellen Erstellung einer Tabelle mit der AWS Glue-Konsole finden Sie unter [Erstellen von Tabellen](tables-described.md).

**Anmerkung**  
Sie können die AWS Lake Formation Konsole nicht verwenden, um die Tabelle zu erstellen. Sie müssen die AWS Glue Konsole verwenden.

Beachten Sie auch die folgenden Informationen für Streaming-Quellen im Avro-Format oder für Protokolldaten, auf die Sie Grok-Muster anwenden können. 
+ [Hinweise und Einschränkungen für Avro-Streaming-Quellen](#streaming-avro-notes)
+ [Anwenden von Grok-Mustern auf Streaming-Quellen](#create-table-streaming-grok)

**Topics**
+ [Kinesis-Datenquelle](#kinesis-source)
+ [Kafka-Datenquelle](#kafka-source)
+ [Quelle der AWS Glue Schema Registry-Tabelle](#schema-registry-table)

### Kinesis-Datenquelle
<a name="kinesis-source"></a>

Legen Sie beim Erstellen der Tabelle die folgenden Streaming-ETL-Eigenschaften fest (Konsole).

**Quelltyp**  
**Kinesis**

**Für eine Kinesis-Quelle im selben Konto:**    
**Region**  
Die AWS Region, in der sich der Amazon Kinesis Data Streams Streams-Service befindet. Der Name der Region und des Kinesis-Streams werden zusammen in einen Stream-ARN übersetzt.  
Beispiel: https://kinesis.us-east-1.amazonaws.com  
**Kinesis-Streamname**  
Der Stream-Name wie unter [Erstellen eines Streams](https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-create-stream.html) im* Entwicklerhandbuch zu Amazon Kinesis Data Streams* beschrieben.

**Informationen zu einer Kinesis-Quelle in einem anderen Konto finden Sie in [diesem Beispiel](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html) zum Einrichten der Rollen und Richtlinien, um den kontenübergreifenden Zugriff zu ermöglichen. Konfigurieren Sie diese Einstellungen:**    
**ARN streamen**  
Der ARN des Kinesis-Datenstroms, mit dem der Verbraucher registriert ist. Weitere Informationen finden Sie unter [Amazon Resource Names (ARNs) und AWS Service Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) in der. *Allgemeine AWS-Referenz*  
**Angenommene ARN-Rolle**  
Der angenommene Amazon-Ressourcenname (ARN) der Rolle.  
**Sitzungsname (optional)**  
Ein Bezeichner für die Sitzung der angenommenen Rolle.  
Verwenden Sie den Namen der Rollensitzung, um eine Sitzung eindeutig zu identifizieren, wenn dieselbe Rolle von verschiedenen Prinzipalen oder aus unterschiedlichen Gründen übernommen wird. In kontenübergreifenden Szenarien ist der Name der Rollensitzung für das Konto sichtbar und kann von dem Konto protokolliert werden, dem die Rolle gehört. Der Rollensitzungsname wird auch im ARN des übernommenen Rollenprinzipals verwendet. Das bedeutet, dass nachfolgende kontoübergreifende API-Anfragen, die die temporären Sicherheitsanmeldedaten verwenden, den Namen der Rollensitzung für das externe Konto in ihren Protokollen offenlegen. AWS CloudTrail 

**Streaming-ETL-Eigenschaften für Amazon Kinesis Data Streams festlegen (AWS Glue-API oder AWS CLI)**
+ Um Streaming-ETL-Eigenschaften für eine Kinesis-Quelle in demselben Konto einzurichten, geben Sie die `streamName`- und `endpointUrl`-Parameter in der `StorageDescriptor`-Struktur der `CreateTable`-API-Operation oder dem `create_table`-CLI-Befehl an.

  ```
  "StorageDescriptor": {
  	"Parameters": {
  		"typeOfData": "kinesis",
  		"streamName": "sample-stream",
  		"endpointUrl": "https://kinesis.us-east-1.amazonaws.com"
  	}
  	...
  }
  ```

  Oder geben Sie den `streamARN` an.  
**Example**  

  ```
  "StorageDescriptor": {
  	"Parameters": {
  		"typeOfData": "kinesis",
  		"streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream"
  	}
  	...
  }
  ```
+ Um Streaming-ETL-Eigenschaften für eine Kinesis-Quelle in einem anderen Konto einzurichten, geben Sie die `streamARN`-, `awsSTSRoleARN`- und (optional) `awsSTSSessionName`-Parameter in der `StorageDescriptor`-Struktur der `CreateTable`-API-Operation oder dem `create_table`-CLI-Befehl an.

  ```
  "StorageDescriptor": {
  	"Parameters": {
  		"typeOfData": "kinesis",
  		"streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream",
  		"awsSTSRoleARN": "arn:aws:iam::123456789:role/sample-assume-role-arn",
  		"awsSTSSessionName": "optional-session"
  	}
  	...
  }
  ```

### Kafka-Datenquelle
<a name="kafka-source"></a>

Legen Sie beim Erstellen der Tabelle die folgenden Streaming-ETL-Eigenschaften fest (Konsole).

**Quelltyp**  
 **Kafka**

**Für eine Kafka-Quelle:**    
**Themenname**  
Der Topic-Name wie in Kafka angegeben.  
**Connection (Verbindung)**  
Eine AWS Glue-Verbindung, die auf eine Kafka-Quelle verweist, wie unter [Erstellen einer AWS Glue-Verbindung für einen Apache-Kafka-Datenstrom](#create-conn-streaming) beschrieben.

### Quelle der AWS Glue Schema Registry-Tabelle
<a name="schema-registry-table"></a>

Um AWS Glue Schema Registry für Streaming-Aufträge zu verwenden, folgen Sie den Anweisungen unter [Anwendungsfall: AWS Glue Data Catalog](schema-registry-integrations.md#schema-registry-integrations-aws-glue-data-catalog), um eine Schema Registry-Tabelle zu erstellen oder zu aktualisieren.

Derzeit unterstützt AWS Glue Streaming nur das Avro-Format der Glue Schema Registry, wobei die Schemainferenz auf `false` eingestellt ist.

## Hinweise und Einschränkungen für Avro-Streaming-Quellen
<a name="streaming-avro-notes"></a>

Die folgenden Hinweise und Einschränkungen gelten für Streaming-Quellen im Avro-Format:
+ Wenn die Schemaerkennung aktiviert ist, muss das Avro-Schema in die Nutzlast einbezogen werden. Wenn diese Option deaktiviert ist, sollte die Nutzlast nur Daten enthalten.
+ Einige Avro-Datentypen werden in Dynamic Frames nicht unterstützt. Sie können diese Datentypen nicht angeben, wenn Sie das Schema auf der Seite **Definieren eines Schemas** im Tabellenerstellungs-Assistenten der AWS Glue-Konsole definieren. Während der Schemaerkennung werden nicht unterstützte Typen im Avro-Schema wie folgt in unterstützte Typen konvertiert:
  + `EnumType => StringType`
  + `FixedType => BinaryType`
  + `UnionType => StructType`
+ Wenn Sie das Tabellenschema auf der Seite **Definieren eines Schemas** in der Konsole definieren, ist der implizierte Stammelementtyp für das Schema `record`. Wenn Sie einen anderen Stammelementtyp als `record` möchten, zum Beispiel `array` oder `map`, können Sie das Schema nicht mithilfe der Seite **Definieren eines Schemas** angeben. Stattdessen müssen Sie diese Seite überspringen und das Schema entweder als Tabelleneigenschaft oder im ETL-Skript angeben.
  + Um das Schema in den Tabelleneigenschaften anzugeben, füllen Sie den Assistenten zum Erstellen von Tabellen aus, bearbeiten Sie die Tabellendetails und fügen Sie unter **Tabelleneigenschaften** ein neues Schlüssel-Wert-Paar hinzu. Verwenden Sie den Schlüssel `avroSchema` und geben Sie ein Schema-JSON-Objekt für den Wert ein, wie im folgenden Screenshot gezeigt.  
![\[Unter der Überschrift Tabelleneigenschaften gibt es zwei Spalten mit Textfeldern. Die linke Spaltenüberschrift ist Schlüssel und die rechte Spaltenüberschrift ist Wert. Das key/value Paar in der ersten Zeile ist das classification/avro. The key/value Paar in der zweiten Zeile avroSchema/ {"type“ :"array“, "items“ :"string "}.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/table_properties_avro.png)
  + Um das Schema im ETL-Skript anzugeben, ändern Sie die `datasource0`-Zuweisungsanweisung und fügen Sie den Schlüssel `avroSchema` zum Argument `additional_options` hinzu, wie in den folgenden Python- und Scala-Beispielen gezeigt.

------
#### [ Python ]

    ```
    SCHEMA_STRING = ‘{"type":"array","items":"string"}’
    datasource0 = glueContext.create_data_frame.from_catalog(database = "database", table_name = "table_name", transformation_ctx = "datasource0", additional_options = {"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema": SCHEMA_STRING})
    ```

------
#### [ Scala ]

    ```
    val SCHEMA_STRING = """{"type":"array","items":"string"}"""
    val datasource0 = glueContext.getCatalogSource(database = "database", tableName = "table_name", redshiftTmpDir = "", transformationContext = "datasource0", additionalOptions = JsonOptions(s"""{"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema":"$SCHEMA_STRING"}""")).getDataFrame()
    ```

------

## Anwenden von Grok-Mustern auf Streaming-Quellen
<a name="create-table-streaming-grok"></a>

Sie können einen Streaming-ETL-Auftrag für eine Protokolldatenquelle erstellen und Grok-Muster verwenden, um die Protokolle in strukturierte Daten zu konvertieren. Der ETL-Auftrag verarbeitet die Daten dann als strukturierte Datenquelle. Sie geben die Grok-Muster an, die angewendet werden sollen, wenn Sie die Data-Catalog-Tabelle für die Streaming-Quelle erstellen.

Informationen zu Grok-Mustern und benutzerdefinierten Musterzeichenfolgenwerten finden Sie unter [Angepasste Grok-Classifier schreiben](custom-classifier.md#custom-classifier-grok).

**So fügen Sie der Data-Catalog-Tabelle (Konsole) Grok-Muster hinzu**
+ Verwenden Sie den Assistenten zum Erstellen von Tabellen, und erstellen Sie die Tabelle mit den in [Erstellen einer Data-Catalog-Tabelle für eine Streaming-Quelle](#create-table-streaming) angegebenen Parametern. Geben Sie als Datenformat Grok an, füllen Sie das Feld **Grok-Muster** aus und fügen Sie optional benutzerdefinierte Muster unter **Benutzerdefinierte Muster (optional)** hinzu.  
![\[*\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/grok-data-format-create-table.png)

  Drücken Sie nach jedem benutzerdefinierten Muster auf **Eingabe**.

**Um Grok-Muster zur Datenkatalogtabelle hinzuzufügen (API oder) AWS Glue AWS CLI**
+ Fügen Sie den `GrokPattern`-Parameter und optional den `CustomPatterns`-Parameter zu der `CreateTable`-API-Operation oder dem `create_table`-CLI-Befehl hinzu.

  ```
   "Parameters": {
  ...
      "grokPattern": "string",
      "grokCustomPatterns": "string",
  ...
  },
  ```

  Drücken Sie `grokCustomPatterns` als String aus und verwenden Sie „\$1 n“ als Trennzeichen zwischen Mustern.

  Nachfolgend finden Sie ein Beispiel für die Angabe dieser Parameter.  
**Example**  

  ```
  "parameters": {
  ...
      "grokPattern": "%{USERNAME:username} %{DIGIT:digit:int}",
      "grokCustomPatterns": "digit \d",
  ...
  }
  ```

## Definieren von Auftragseigenschaften für einen Streaming-ETL-Auftrag
<a name="create-job-streaming-properties"></a>

Wenn Sie in der AWS Glue-Konsole einen Streaming-ETL-Auftrag definieren, geben Sie die folgenden Streaming-spezifischen Eigenschaften an. Beschreibungen weiterer Auftragseigenschaften finden Sie unter [Definieren von Auftragseigenschaften für Spark-Aufträge](add-job.md#create-job). 

**IAM role (IAM-Rolle)**  
Geben Sie die AWS Identity and Access Management (IAM-) Rolle an, die für die Autorisierung von Ressourcen verwendet wird, die für die Ausführung des Jobs, den Zugriff auf Streaming-Quellen und den Zugriff auf Zieldatenspeicher verwendet werden.  
Für den Zugriff auf Amazon Kinesis Data Streams hängen Sie die `AmazonKinesisFullAccess` AWS verwaltete Richtlinie an die Rolle an oder fügen Sie eine ähnliche IAM-Richtlinie hinzu, die einen detaillierteren Zugriff ermöglicht. Beispielrichtlinien finden Sie unter [Steuern des Zugriffs auf Amazon Kinesis Data Streams-Ressourcen mithilfe von IAM](https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html).  
Weitere Informationen über die Berechtigungen für die Ausführung von Aufträgen in AWS Glue finden Sie unter [Identitäts- und Zugriffsmanagement für AWS Glue](security-iam.md).

**Typ**  
Wählen Sie **Spark streaming (Spark-Streaming)**.

**AWS Glue-Version**  
Die AWS Glue-Version bestimmt die Versionen von Apache Spark und Python oder Scala, die für den Auftrag verfügbar sind. Treffen Sie eine Auswahl, die die für den Auftrag verfügbare Version von Python oder Scala angibt. AWS Glue Version 2.0 mit Python-3-Unterstützung ist die Standardeinstellung für Streaming-ETL-Aufträge.

**Wartungsfenster**  
Gibt ein Fenster an, in dem ein Streamingauftrag neu gestartet werden kann. Siehe [Wartungsfenster für AWS Glue Streaming](glue-streaming-maintenance.md).

**Zeitüberschreitung von Aufträgen**  
Geben Sie optional eine Dauer in Minuten ein. Der Standardwert ist leer.  
+ Streamingaufträge müssen einen Timeout-Wert von weniger als 7 Tagen oder 10 080 Minuten haben.
+ Wenn der Wert leer gelassen wird, wird der Auftrag nach 7 Tagen neu gestartet, sofern Sie kein Wartungsfenster eingerichtet haben. Wenn Sie ein Wartungsfenster eingerichtet haben, wird der Auftrag während des Wartungsfensters nach 7 Tagen neu gestartet.

**Datenquelle**  
Geben Sie die Tabelle an, die Sie in [Erstellen einer Data-Catalog-Tabelle für eine Streaming-Quelle](#create-table-streaming) erstellt haben.

**Datenziel**  
Führen Sie eine der folgenden Aktionen aus:  
+ Wählen Sie **Create tables in your data target (Tabellen in eigenem Datenziel erstellen)** und geben Sie die folgenden Eigenschaften für das Datenziel an.  
**Datastore**  
Wählen Sie Amazon S3 oder JDBC.  
**Format**  
Wählen Sie ein beliebiges Format aus. Für das Streaming werden alle unterstützt.
+ Wählen Sie **Use tables in the data catalog and update your data target (Tabellen im Data Catalog verwenden und Datenziel aktualisieren)** und wählen Sie eine Tabelle für einen JDBC-Datastore.

**Ausgabeschemadefinition**  
Führen Sie eine der folgenden Aktionen aus:  
+ Klicken Sie auf **Automatically detect schema of each record (Schema jedes Datensatzes automatisch erkennen)** um die Schemaerkennung zu aktivieren. AWS Glue bestimmt das Schema aus den Streamingdaten.
+ Klicken Sie auf **Specify output schema for all records (Ausgabeschema für alle Datensätze angeben)**, um das Ausgabeschema mithilfe der Transformation „Apply Mapping“ (Mapping anwenden) zu definieren.

**Script**  
Geben Sie optional Ihr eigenes Skript an oder ändern Sie das generierte Skript, um Operationen auszuführen, die von der Apache-Spark-Engine Structured Streaming unterstützt werden. Informationen zu den verfügbaren Vorgängen finden Sie unter [Operationen](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets) auf Streaming/Datasets. DataFrames

## Hinweise zu und Einschränkungen für Streaming-ETL
<a name="create-job-streaming-restrictions"></a>

Beachten Sie die folgenden Hinweise und Einschränkungen:
+ Auto-Dekomprimierung für das AWS Glue-Streaming von ETL-Aufträgen ist nur für die unterstützten Komprimierungstypen verfügbar. Beachten Sie auch das Folgende:
  + Das gerahmte Snappy bezieht sich auf das offizielle [Rahmen-Format](https://github.com/google/snappy/blob/main/framing_format.txt) für Snappy.
  + Deflate wird in der Glue-Version 3.0 unterstützt, nicht in der Glue-Version 2.0.
+ Wenn Sie die Schemaerkennung verwenden, können Sie keine Joins von Streamingdaten ausführen.
+ AWS Glue-Streaming von ETL-Aufträgen unterstützt nicht den Union-Datentyp für AWS Glue-Schemaregistrierung im Avro-Format.
+ Ihr ETL-Skript kann die nativen Transformationen von Apache Spark Structured Streaming in AWS Glue verwenden. Weitere Informationen finden Sie unter [Operationen beim Streamen DataFrames /Datasets auf](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets) der Apache Spark-Website oder. [AWS Glue PySpark transformiert Referenz](aws-glue-programming-python-transforms.md)
+ AWS Glue verwendet für das Streaming von ETL-Aufträgen Checkpoints zum Nachverfolgen der gelesenen Daten. Daher wird ein Auftrag, der angehalten und neu gestartet wurde, an dem Punkt fortgesetzt, an dem er im Stream beendet wurde. Wenn Sie Daten neu verarbeiten möchten, können Sie den Checkpoint-Ordner löschen, auf den im Skript verwiesen wird.
+ Auftragslesezeichen werden nicht unterstützt.
+ Zur Verwendung des erweiterten Fan-Out-Features von Kinesis Data Streams in Ihrem Auftrag lesen Sie [Verwendung von erweitertem Fan-Out in Kinesis-Streaming-Aufträgen](aws-glue-programming-etl-connect-kinesis-efo.md).
+ Wenn Sie eine Data Katalog-Tabelle verwenden, die aus AWS Glue Schema Registry erstellt wurde, wenn eine neue Schemaversion verfügbar wird, müssen Sie Folgendes tun, um das neue Schema widerzuspiegeln:

  1. Stoppen Sie die mit der Tabelle verknüpften Aufträge.

  1. Aktualisieren Sie das Schema für die Data Catalog-Tabelle.

  1. Starten Sie die mit der Tabelle verknüpften Aufträge neu.