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.
# Verbindungstypen und Optionen für ETL in AWS Glue für Spark
In AWS Glue Spark spezifizieren verschiedene PySpark und Scala-Methoden und Transformationen den Verbindungstyp mithilfe eines `connectionType` Parameters. Sie geben Verbindungsoptionen mit einem `connectionOptions`- oder `options`-Parameter an.
Der `connectionType`-Parameter kann die in der folgenden Tabelle angegebenen Werte annehmen. Die zugehörigen `connectionOptions`- (oder `options`)-Parameterwerte für jeden Typ sind in den folgenden Abschnitten dokumentiert. Sofern nicht anders angegeben, gelten die Parameter, wenn die Verbindung als Quelle oder Senke verwendet wird.
Beispielcode, der das Festlegen und Verwenden von Verbindungsoptionen veranschaulicht, finden Sie auf der Homepage für jeden Verbindungstyp.
| `connectionType` | Verbindet mit |
| --- | --- |
| [dynamodb](aws-glue-programming-etl-connect-dynamodb-home.md) | [Amazon-DynamoDB-Datenbank](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) |
| [kinesis](aws-glue-programming-etl-connect-kinesis-home.md) | [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) |
| [S3](aws-glue-programming-etl-connect-s3-home.md) | [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/) |
| [documentdb](aws-glue-programming-etl-connect-documentdb-home.md#aws-glue-programming-etl-connect-documentdb) | [Amazon-DocumentDB-Datenbank (mit MongoDB-Kompatibilität)](https://docs.aws.amazon.com/documentdb/latest/developerguide/) |
| [opensearch](aws-glue-programming-etl-connect-opensearch-home.md) | [ OpenSearch Amazon-Dienst](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/). |
| [redshift](aws-glue-programming-etl-connect-redshift-home.md) | [Amazon Redshift](https://aws.amazon.com/redshift/)-Datenbank |
| [kafka](aws-glue-programming-etl-connect-kafka-home.md) | [Kafka](https://kafka.apache.org/) oder [Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) |
| [azurecosmos](aws-glue-programming-etl-connect-azurecosmos-home.md) | Azure Cosmos for NoSQL. |
| [azuresql](aws-glue-programming-etl-connect-azuresql-home.md) | Azure SQL. |
| [bigquery](aws-glue-programming-etl-connect-bigquery-home.md) | Google BigQuery. |
| [mongodb](aws-glue-programming-etl-connect-mongodb-home.md) | [MongoDB](https://www.mongodb.com/what-is-mongodb)-Datenbank, einschließlich MongoDB Atlas. |
| [sqlserver](aws-glue-programming-etl-connect-jdbc-home.md) | Microsoft SQL Server-Datenbank (siehe [JDBC-Verbindungen](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [mysql-](aws-glue-programming-etl-connect-jdbc-home.md) | [MySQL](https://www.mysql.com/)-Datenbankserver (siehe [JDBC-Verbindungen](aws-glue-programming-etl-connect-jdbc-home.md)). |
| [oracle](aws-glue-programming-etl-connect-jdbc-home.md) | [Oracle](https://www.oracle.com/database/)-Datenbank (siehe [JDBC-Verbindungen](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [postgresql](aws-glue-programming-etl-connect-jdbc-home.md) | [PostgreSQL](https://www.postgresql.org/)-Datenbank (siehe [JDBC-Verbindungen](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [saphana](aws-glue-programming-etl-connect-saphana-home.md) | SAP HANA. |
| [snowflake](aws-glue-programming-etl-connect-snowflake-home.md) | [Snowflake](https://www.snowflake.com/) Data Lake |
| [teradata](aws-glue-programming-etl-connect-teradata-home.md) | Teradata Vantage. |
| [vertica](aws-glue-programming-etl-connect-vertica-home.md) | Vertica. |
| [benutzerdefiniert.\$1](#aws-glue-programming-etl-connect-market) | Spark-, Athena- oder JDBC-Datenspeicher (siehe [Custom- und AWS Marketplace ConnectionType-Werte](#aws-glue-programming-etl-connect-market) |
| [marketplace.\$1](#aws-glue-programming-etl-connect-market) | Spark-, Athena- oder JDBC-Datenspeicher (siehe [Custom- und AWS Marketplace ConnectionType-Werte](#aws-glue-programming-etl-connect-market)) |
# DynamoDB-Verbindungen
Sie können AWS Glue for Spark verwenden, um in DynamoDB in Glue aus Tabellen zu lesen und in sie zu schreiben. AWS Sie stellen mithilfe der IAM-Berechtigungen, die mit Ihrem AWS Glue-Job verknüpft sind, eine Verbindung zu DynamoDB her. AWS Glueunterstützt das Schreiben von Daten in die DynamoDB-Tabelle eines anderen AWS Kontos. Weitere Informationen finden Sie unter [Konten- und regionenübergreifender Zugriff auf DynamoDB-Tabellen](aws-glue-programming-etl-dynamo-db-cross-account.md).
Der ursprüngliche DynamoDB-Konnektor verwendet DynamicFrame Glue-Objekte, um mit den aus DynamoDB extrahierten Daten zu arbeiten. AWS Glue 5.0\$1 führt eine neue Version ein[DynamoDB-Konnektor mit Spark-Unterstützung DataFrame](aws-glue-programming-etl-connect-dynamodb-dataframe-support.md), die native DataFrame Spark-Unterstützung bietet.
[Zusätzlich zum AWS Glue DynamoDB-ETL-Connector können Sie mithilfe des DynamoDB-Export-Connectors aus DynamoDB lesen, der eine `ExportTableToPointInTime` DynamoDB-Anfrage aufruft und sie an einem von Ihnen angegebenen Amazon S3 S3-Speicherort im Format von DynamoDB JSON speichert.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html) AWS Glueerstellt dann ein DynamicFrame Objekt, indem die Daten vom Amazon S3 S3-Exportspeicherort gelesen werden.
Der DynamoDB Writer wird in AWS Glue Version 1.0 oder höher unterstützt. Der AWS Glue-DynamoDB-Export-Konnektor wird in AWS Glue Version 2.0 oder höher unterstützt. Der neue DataFrame basierte DynamoDB-Connector ist in AWS Glue Version 5.0 oder späteren Versionen verfügbar.
Weitere Informationen zu DynamoDB finden Sie in der Dokumentation zu [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/).
**Anmerkung**
Der DynamoDB-ETL-Reader unterstützt keine Filter oder Pushdown-Prädikate.
## Konfigurieren von DynamoDB-Verbindungen
Um von AWS Glue aus eine Verbindung zu DynamoDB herzustellen, erteilen Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle die Erlaubnis, mit DynamoDB zu interagieren. Weitere Informationen zu Berechtigungen auf Ressourcenebene, die zum Lesen und Schreiben in DynamoDB erforderlich sind, finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für DynamoDB](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html) in der Dokumentation zu IAM.
In den folgenden Situationen ist möglicherweise eine zusätzliche Konfiguration erforderlich:
+ Wenn Sie den DynamoDB-Export-Konnektor verwenden, müssen Sie IAM so konfigurieren, dass Ihr Auftrag DynamoDB-Tabellenexporte anfordern kann. Darüber hinaus müssen Sie einen Amazon S3 S3-Bucket für den Export identifizieren und entsprechende Berechtigungen in IAM bereitstellen, damit DynamoDB in diesen Bucket schreiben und Ihr AWS Glue-Job daraus lesen kann. Weitere Informationen finden Sie unter [Anfordern eines Tabellenexports in DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/S3DataExport_Requesting.html).
+ Wenn Ihr AWS Glue-Job spezielle Amazon VPC-Konnektivitätsanforderungen hat, verwenden Sie den `NETWORK` AWS Glue-Verbindungstyp, um Netzwerkoptionen bereitzustellen. Da der Zugriff auf DynamoDB von IAM autorisiert wird, ist kein AWS Glue DynamoDB-Verbindungstyp erforderlich.
## Aus DynamoDB lesen und in DynamoDB schreiben
In den folgenden Codebeispielen wird gezeigt, wie DynamoDB-Tabellen (über den ETL Connector) gelesen und geschrieben werden. Sie demonstrieren das Lesen von einer Tabelle und das Schreiben in eine andere Tabelle.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame.from_options(
connection_type="dynamodb",
connection_options={"dynamodb.input.tableName": test_source,
"dynamodb.throughput.read.percent": "1.0",
"dynamodb.splits": "100"
}
)
print(dyf.getNumPartitions())
glue_context.write_dynamic_frame_from_options(
frame=dyf,
connection_type="dynamodb",
connection_options={"dynamodb.output.tableName": test_sink,
"dynamodb.throughput.write.percent": "1.0"
}
)
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.input.tableName" -> test_source,
"dynamodb.throughput.read.percent" -> "1.0",
"dynamodb.splits" -> "100"
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
val dynamoDbSink: DynamoDbDataSink = glueContext.getSinkWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.output.tableName" -> test_sink,
"dynamodb.throughput.write.percent" -> "1.0"
))
).asInstanceOf[DynamoDbDataSink]
dynamoDbSink.writeDynamicFrame(dynamicFrame)
Job.commit()
}
}
```
------
## Verwenden des DynamoDB-Export-Konnektors
Der Export-Konnektor funktioniert besser als der ETL-Konnektor, wenn die DynamoDB-Tabelle größer als 80 GB ist. Da außerdem die Exportanforderung außerhalb der Spark-Prozesse in einem AWS Glue-Auftrag durchgeführt wird, können Sie [Auto Scaling von AWS -Glue-Aufträgen](https://docs.aws.amazon.com/glue/latest/dg/auto-scaling.html) aktivieren, um bei der Export-Anforderung die DPU-Auslastung zu verringern. Mit dem Export-Konnektor müssen Sie auch nicht die Anzahl der Aufteilungen für die Parallelität des Spark-Executors oder den Prozentsatz des DynamoDB-Durchsatzes konfigurieren.
**Anmerkung**
DynamoDB hat spezifische Anforderungen, um `ExportTableToPointInTime`-Anforderungen aufzurufen. Weitere Informationen finden Sie unter [Anfordern eines Tabellenexports in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Requesting.html). Beispielsweise muss Point-in-Time-Restore (PITR) in der Tabelle aktiviert sein, um diesen Konnektor verwenden zu können. Der DynamoDB-Connector unterstützt auch die AWS KMS Verschlüsselung für DynamoDB-Exporte nach Amazon S3. Wenn Sie Ihre Sicherheitskonfiguration in der AWS Glue-Job-Konfiguration angeben, wird die AWS KMS Verschlüsselung für einen DynamoDB-Export aktiviert. Der KMS-Schlüssel muss sich in derselben Region wie der Amazon-S3-Bucket befinden.
Beachten Sie, dass zusätzliche Gebühren für den DynamoDB-Export und Amazon-S3-Speicherkosten anfallen. Exportierte Daten in Amazon S3 bleiben bestehen, nachdem ein Auftrag ausgeführt wurde, sodass Sie sie ohne zusätzliche DynamoDB-Exporte wiederverwenden können. Voraussetzung für die Verwendung dieses Connectors ist, dass point-in-time Recovery (PITR) für die Tabelle aktiviert ist.
Der DynamoDB-ETL-Konnektor oder Export-Konnektor unterstützt keine Filter oder Pushdown-Prädikate, die an der DynamoDB-Quelle angewendet werden sollen.
In den folgenden Codebeispielen wird gezeigt, wie die Anzahl der Partitionen (über den Export-Konnektor) gelesen und gedruckt werden.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame.from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.export": "ddb",
"dynamodb.tableArn": test_source,
"dynamodb.s3.bucket": bucket_name,
"dynamodb.s3.prefix": bucket_prefix,
"dynamodb.s3.bucketOwner": account_id_of_bucket,
}
)
print(dyf.getNumPartitions())
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> test_source,
"dynamodb.s3.bucket" -> bucket_name,
"dynamodb.s3.prefix" -> bucket_prefix,
"dynamodb.s3.bucketOwner" -> account_id_of_bucket,
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
Job.commit()
}
}
```
------
Diese Beispiele zeigen, wie aus einer AWS Glue Data Catalog-Tabelle, die eine `dynamodb` Klassifizierung hat, gelesen (über den Export-Connector) und wie die Anzahl der Partitionen gedruckt wird:
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dynamicFrame = glue_context.create_dynamic_frame.from_catalog(
database=catalog_database,
table_name=catalog_table_name,
additional_options={
"dynamodb.export": "ddb",
"dynamodb.s3.bucket": s3_bucket,
"dynamodb.s3.prefix": s3_bucket_prefix
}
)
print(dynamicFrame.getNumPartitions())
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getCatalogSource(
database = catalog_database,
tableName = catalog_table_name,
additionalOptions = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.s3.bucket" -> s3_bucket,
"dynamodb.s3.prefix" -> s3_bucket_prefix
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
)
```
------
## Vereinfachung der Verwendung einer DynamoDB-Export-JSON
DynamoDB-Exporte mit dem AWS Glue-DynamoDB-Export-Konnektor ergeben JSON-Dateien mit speziellen verschachtelten Strukturen. Weitere Informationen finden Sie unter [Datenobjekte](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). AWS Gluestellt eine DynamicFrame Transformation bereit, mit der solche Strukturen in ein easier-to-use Formular für nachgelagerte Anwendungen umgewandelt werden können.
Die Transformation kann auf zwei Arten aufgerufen werden. Beim Aufrufen einer Methode zum Lesen aus DynamoDB können Sie die Verbindungsoption `"dynamodb.simplifyDDBJson"` mit dem Wert `"true"` festlegen. Sie können die Transformation auch als eigenständige Methode aufrufen, die in der AWS Glue-Bibliothek verfügbar ist.
Betrachten Sie das folgende Schema, das durch einen DynamoDB-Export generiert wurde:
```
root
|-- Item: struct
| |-- parentMap: struct
| | |-- M: struct
| | | |-- childMap: struct
| | | | |-- M: struct
| | | | | |-- appName: struct
| | | | | | |-- S: string
| | | | | |-- packageName: struct
| | | | | | |-- S: string
| | | | | |-- updatedAt: struct
| | | | | | |-- N: string
| |-- strings: struct
| | |-- SS: array
| | | |-- element: string
| |-- numbers: struct
| | |-- NS: array
| | | |-- element: string
| |-- binaries: struct
| | |-- BS: array
| | | |-- element: string
| |-- isDDBJson: struct
| | |-- BOOL: boolean
| |-- nullValue: struct
| | |-- NULL: boolean
```
Die Transformation `simplifyDDBJson` vereinfacht dies zu:
```
root
|-- parentMap: struct
| |-- childMap: struct
| | |-- appName: string
| | |-- packageName: string
| | |-- updatedAt: string
|-- strings: array
| |-- element: string
|-- numbers: array
| |-- element: string
|-- binaries: array
| |-- element: string
|-- isDDBJson: boolean
|-- nullValue: null
```
**Anmerkung**
`simplifyDDBJson`ist in AWS Glue 3.0 und späteren Versionen verfügbar. Mit der Transformation `unnestDDBJson` können Sie auch das JSON aus einem DynamoDB-Export vereinfachen. Wir empfehlen Benutzern, von `unnestDDBJson` auf `simplifyDDBJson` umzusteigen.
## Konfigurieren der Parallelisierung bei DynamoDB-Vorgängen
Um die Leistung zu verbessern, können Sie bestimmte für den DynamoDB-Konnektor verfügbare Parameter anpassen. Ihr Ziel bei der Optimierung der Parallelitätsparameter besteht darin, die Nutzung der bereitgestellten AWS Glue-Worker zu maximieren. Wenn Sie dann mehr Leistung benötigen, empfehlen wir Ihnen, Ihren Job zu skalieren, indem Sie die Anzahl der Aufgaben erhöhen. DPUs
Sie können die Parallelisierung in einem DynamoDB-Lesevorgang mit dem Parameter `dynamodb.splits` ändern, wenn Sie den ETL-Konnektor verwenden. Wenn Sie den Export-Konnektor zum Lesen verwenden, müssen Sie die Anzahl der Splits für die Spark-Executor-Parallelisierung nicht konfigurieren. Sie können die Parallelisierung in einem DynamoDB-Schreibvorgang mit `dynamodb.output.numParallelTasks` ändern.
**Lesen mit dem DynamoDB-ETL-Konnektor**
Wir empfehlen Ihnen, die Berechnung von `dynamodb.splits` auf der Grundlage der in Ihrer Auftragskonfiguration festgelegten maximalen Anzahl von Workern und der folgenden `numSlots`-Berechnung durchzuführen. Bei einer automatischen Skalierung kann sich die tatsächliche Anzahl verfügbarer Worker unter dieser Obergrenze ändern. Weitere Informationen zur Festlegung der Höchstzahl an Workern finden Sie unter **Anzahl der Worker** (`NumberOfWorkers`) in[Konfiguration der Auftragseigenschaften für Spark-Jobs in AWS Glue](add-job.md).
+ `numExecutors = NumberOfWorkers - 1`
Für den Kontext ist ein Executor für den Spark-Treiber reserviert; andere Executors werden für die Datenverarbeitung verwendet.
+ `numSlotsPerExecutor =`
------
#### [ AWS Glue 3.0 and later versions ]
+ `4` wenn `WorkerType` gleich `G.1X`
+ `8` wenn `WorkerType` gleich `G.2X`
+ `16` wenn `WorkerType` gleich `G.4X`
+ `32` wenn `WorkerType` gleich `G.8X`
------
#### [ AWS Glue 2.0 and legacy versions ]
+ `8` wenn `WorkerType` gleich `G.1X`
+ `16` wenn `WorkerType` gleich `G.2X`
------
+ `numSlots = numSlotsPerExecutor * numExecutors`
Wir empfehlen Ihnen `dynamodb.splits` auf die Anzahl der verfügbaren Slots einzustellen, `numSlots`.
**In DynamoDB schreiben**
Der Parameter `dynamodb.output.numParallelTasks` wird verwendet, um die WCU pro Spark-Aufgabe anhand der folgenden Berechnung zu bestimmen:
`permittedWcuPerTask = ( TableWCU * dynamodb.throughput.write.percent ) / dynamodb.output.numParallelTasks`
Der DynamoDB-Writer funktioniert am besten, wenn die Konfiguration die Anzahl der Spark-Aufgaben, die in DynamoDB schreiben, genau wiedergibt. In manchen Fällen müssen Sie die Standardberechnung außer Kraft setzen, um die Schreibleistung zu verbessern. Wenn Sie diesen Parameter nicht angeben, wird die zulässige WCU pro Spark-Aufgabe automatisch nach der folgenden Formel berechnet:
+
+ `numPartitions = dynamicframe.getNumPartitions()`
+ `numSlots` (wie zuvor in diesem Abschnitt definiert)
+ `numParallelTasks = min(numPartitions, numSlots)`
+ Beispiel 1. DPU=10, =Standard. WorkerType Die Eingabe DynamicFrame hat 100 RDD-Partitionen.
+ `numPartitions = 100`
+ `numExecutors = (10 - 1) * 2 - 1 = 17`
+ `numSlots = 4 * 17 = 68`
+ `numParallelTasks = min(100, 68) = 68`
+ Beispiel 2. DPU = 10, =Standard. WorkerType Die Eingabe DynamicFrame hat 20 RDD-Partitionen.
+ `numPartitions = 20`
+ `numExecutors = (10 - 1) * 2 - 1 = 17`
+ `numSlots = 4 * 17 = 68`
+ `numParallelTasks = min(20, 68) = 20`
**Anmerkung**
Jobs auf älteren AWS Glue-Versionen und solche, die Standard-Worker verwenden, erfordern unterschiedliche Methoden zur Berechnung der Anzahl der Slots. Wenn Sie die Leistung dieser Jobs optimieren müssen, empfehlen wir Ihnen, auf unterstützte AWS Glue-Versionen umzusteigen.
## Referenz zur DynamoDB-Verbindungsoption
Bezeichnet eine Verbindung mit Amazon DynamoDB.
Die Anschlussmöglichkeiten bei einer Quellverbindung und eine Senkenverbindung unterscheiden sich.
### „connectionType“: „dynamodb“ mit dem ETL-Konnektor als Quelle
Verwenden Sie die folgenden Verbindungsoptionen `"connectionType": "dynamodb"` als Quelle, wenn Sie den AWS Glue DynamoDB ETL-Konnektor verwenden:
+ `"dynamodb.input.tableName"`: (Erforderlich) Die zu lesende DynamoDB-Tabelle.
+ `"dynamodb.throughput.read.percent"` (optional): Der Prozentsatz der zu verwendenden Lesekapazitätseinheiten (Read Capacity Units, RCU). Der Standard ist auf „0,5“ gesetzt. Zulässigen Werte sind „0,1“ bis „1,5“ inklusive.
+ `0.5` stellt die Standardleserate dar. Dies bedeutet, dass AWS Glue versucht, die Hälfte der Lesekapazität der Tabelle zu verbrauchen. Wenn Sie den Wert über `0.5` anheben, erhöht AWS Glue die Anforderungsrate. Durch Senken des Werts unter `0.5` wird die Leseanforderungsrate verringert. (Die tatsächliche Leserate variiert abhängig von Faktoren wie der Tatsache, ob eine einheitliche Verteilung des Schlüssels in der DynamoDB-Tabelle vorliegt.)
+ Wenn sich die DynamoDB-Tabelle im On-Demand-Modus befindet, legt AWS Glue die Lesekapazität der Tabelle als 40 000 fest. Zum Exportieren einer großen Tabelle empfehlen wir, Ihre DynamoDB-Tabelle in den On-Demand-Modus zu ändern.
+ `"dynamodb.splits"`: (Optional) Definiert die Anzahl der Teile, in die diese DynamoDB-Tabelle beim Lesen partitioniert wird. Der Standard ist auf „1“ gesetzt. Zulässigen Werte sind „1“ bis „1,000,000“ inklusive.
`1` stellt dar, dass es keine Parallelität gibt. Es wird dringend empfohlen, dass Sie einen größeren Wert für eine bessere Leistung angeben, indem Sie die folgende Formel verwenden. Weitere Informationen zur korrekten Einstellung eines Werts finden Sie unter [Konfigurieren der Parallelisierung bei DynamoDB-Vorgängen](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.sts.roleArn"`: (Optional) Die IAM-Rolle ARN, die für den kontoübergreifenden Zugriff angenommen werden soll. Dieser Parameter ist ab AWS Glue 1.0 verfügbar.
+ `"dynamodb.sts.roleSessionName"`: (Optional) Name der STS-Sitzung. Die Standardeinstellung ist "glue-dynamodb-read-sts-session“. Dieser Parameter ist ab AWS Glue 1.0 verfügbar.
### „connectionType“: „dynamodb“ mit dem AWS Glue-DynamoDB-Export-Konnektor als Quelle
Verwenden Sie die folgenden Verbindungsoptionen mit „connectionType“: „dynamodb“ als Quelle, wenn Sie den AWS Glue-DynamoDB-Export-Konnektor verwenden, der nur ab AWS Glue 2.0 verfügbar ist:
+ `"dynamodb.export"`: (Erforderlich) Ein Zeichenfolgenwert:
+ Wenn Sie `ddb` einstellen, wird der AWS Glue-DynamoDB-Export-Konnektor aktiviert, wobei ein neuer `ExportTableToPointInTimeRequest` während des AWS Glue-Auftrags aufgerufen wird. Ein neuer Export wird mit dem Speicherort generiert, der von `dynamodb.s3.bucket` an `dynamodb.s3.prefix` übergeben wurde.
+ Wenn auf `s3` eingestellt, wird der AWS Glue-DynamoDB-Export-Konnektor aktiviert, aber die Erstellung eines neuen DynamoDB-Exports übersprungen. Stattdessen werden `dynamodb.s3.bucket` und `dynamodb.s3.prefix` als Amazon-S3-Speicherort eines früheren Exports der Tabelle verwendet.
+ `"dynamodb.tableArn"`: (Erforderlich) Die zu lesende DynamoDB-Tabelle.
+ `"dynamodb.unnestDDBJson"`: (Optional) Standard: falsch. Zulässige Werte: Boolesch. Wenn der Wert auf „true“ festgelegt ist, wird die Verschachtelung der DynamoDB-JSON-Struktur, die in den Exporten vorhanden ist, durch eine Transformation aufgehoben. Es ist ein Fehler, `"dynamodb.unnestDDBJson"` und `"dynamodb.simplifyDDBJson"` gleichzeitig auf „true“ zu setzen. In AWS Glue 3.0 und späteren Versionen empfehlen wir die Verwendung`"dynamodb.simplifyDDBJson"`, um das Verhalten bei der Vereinfachung von DynamoDB-Zuordnungstypen zu verbessern. Weitere Informationen finden Sie unter [Vereinfachung der Verwendung einer DynamoDB-Export-JSON](#etl-connect-dynamodb-traversing-structure).
+ `"dynamodb.simplifyDDBJson"`: (Optional) Standard: falsch. Zulässige Werte: Boolesch. Wenn der Wert auf „true“ festgelegt ist, wird eine Transformation zur Vereinfachung der DynamoDB-JSON-Struktur, die in den Exporten vorhanden ist, durchgeführt. Dies hat den gleichen Zweck wie die Option `"dynamodb.unnestDDBJson"`, bietet jedoch eine bessere Unterstützung für DynamoDB-Zuordnungstypen oder sogar verschachtelte Zuordnungstypen in Ihrer DynamoDB-Tabelle. Diese Option ist in AWS Glue 3.0 und späteren Versionen verfügbar. Es ist ein Fehler, `"dynamodb.unnestDDBJson"` und `"dynamodb.simplifyDDBJson"` gleichzeitig auf „true“ zu setzen. Weitere Informationen finden Sie unter [Vereinfachung der Verwendung einer DynamoDB-Export-JSON](#etl-connect-dynamodb-traversing-structure).
+ `"dynamodb.s3.bucket"`: (Optional) Gibt den Speicherort des Amazon S3 Bucket an, in dem der DynamoDB `ExportTableToPointInTime`-Prozess durchgeführt werden soll. Das Dateiformat für den Export ist DynamoDB JSON.
+ `"dynamodb.s3.prefix"`: (Optional) Gibt den Speicherort des Amazon S3-Präfixes im AmazonS3 Bucket an, in dem die DynamoDB `ExportTableToPointInTime`-Lasten gespeichert werden sollen. Wenn weder `dynamodb.s3.prefix` noch `dynamodb.s3.bucket` angegeben sind, werden diese Werte standardmäßig auf den in der AWS Glue-Auftragskonfiguration angegebenen Speicherort für das temporäre Verzeichnis gesetzt. Weitere Informationen finden Sie unter [Von AWS Glue verwendete Spezialparameter](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html).
+ `"dynamodb.s3.bucketOwner"`: Zeigt den Bucket-Besitzer an, der für den kontoübergreifenden Amazon-S3-Zugriff benötigt wird.
+ `"dynamodb.sts.roleArn"`: (Optional) Der ARN der IAM-Rolle, der für den and/or kontoübergreifenden Zugriff auf die DynamoDB-Tabelle angenommen werden soll. Hinweis: Dieselbe IAM-Rolle ARN wird für den Zugriff auf den für die `ExportTableToPointInTime`-Anfrage angegebenen Amazon S3-Speicherort verwendet.
+ `"dynamodb.sts.roleSessionName"`: (Optional) Name der STS-Sitzung. Die Standardeinstellung ist "-session“. glue-dynamodb-read-sts
+ `"dynamodb.exportTime"`: (Optional) Gültige Werte: Zeichenfolgen, die ISO-8601-Instanzen darstellen. A, point-in-time an dem der Export erfolgen soll.
+ `"dynamodb.sts.region"`: (Erforderlich, wenn ein regionsübergreifender Aufruf über einen regionalen Endpunkt getätigt wird). Die Region, in der sich die DynamoDB-Tabelle befindet, die Sie lesen möchten.
### „connectionType“: „dynamodb“ mit dem ETL-Konnektor als Senke
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "dynamodb"` als Senke:
+ `"dynamodb.output.tableName"`: (Erforderlich) Die DynamoDB-Tabelle, in die geschrieben werden soll.
+ `"dynamodb.throughput.write.percent"` (optional): Der Prozentsatz der zu verwendenden Schreibkapazitätseinheiten (Write Capacity Units, WCU). Der Standard ist auf „0,5“ gesetzt. Zulässigen Werte sind „0,1“ bis „1,5“ inklusive.
+ `0.5` stellt die Standardschreibrate dar. Dies bedeutet, dass AWS Glue versucht, die Hälfte der Schreibkapazität der Tabelle zu verbrauchen. Wenn Sie den Wert über 0,5 anheben, erhöht AWS Glue die Anforderungsrate. Durch Senken des Werts unter 0,5 wird die Schreibanforderungsrate verringert. (Die tatsächliche Schreibrate variiert abhängig von Faktoren wie der Tatsache, ob eine einheitliche Verteilung des Schlüssels in der DynamoDB-Tabelle vorliegt.)
+ Wenn sich die DynamoDB-Tabelle im On-Demand-Modus befindet, legt AWS Glue die Schreibkapazität der Tabelle als `40000` fest. Zum Importieren einer großen Tabelle empfehlen wir, Ihre DynamoDB-Tabelle in den On-Demand-Modus zu ändern.
+ `"dynamodb.output.numParallelTasks"`: (Optional) definiert, wie viele parallele Aufgaben gleichzeitig in DynamoDB geschrieben werden. Wird verwendet, um berechtigende WCU pro Spark-Aufgabe zu berechnen. In den meisten Fällen berechnet AWS Glue einen angemessenen Standardwert für diesen Wert. Weitere Informationen finden Sie unter [Konfigurieren der Parallelisierung bei DynamoDB-Vorgängen](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.output.retry"`: (Optional) Definiert die Anzahl erneuter Versuche, die durchgeführt werden, wenn es eine `ProvisionedThroughputExceededException` aus DynamoDB gibt. Der Standard ist auf „10“ gesetzt.
+ `"dynamodb.sts.roleArn"`: (Optional) Die IAM-Rolle ARN, die für den kontoübergreifenden Zugriff angenommen werden soll.
+ `"dynamodb.sts.roleSessionName"`: (Optional) Name der STS-Sitzung. Die Standardeinstellung ist "glue-dynamodb-write-sts-session“.
# Konten- und regionenübergreifender Zugriff auf DynamoDB-Tabellen
AWS Glue-ETL-Aufträge unterstützen sowohl Konten- und regionenübergreifenden Zugriff auf DynamoDB-Tabellen. AWS Glue ETL-Jobs unterstützen sowohl das Lesen von Daten aus der DynamoDB-Tabelle eines anderen AWS Kontos als auch das Schreiben von Daten in die DynamoDB-Tabelle eines anderen AWS Kontos. AWS Glueunterstützt auch das Lesen aus einer DynamoDB-Tabelle in einer anderen Region und das Schreiben in eine DynamoDB-Tabelle in einer anderen Region. Dieser Abschnitt enthält Anweisungen zum Einrichten des Zugriffs und enthält ein Beispielskript.
Die Verfahren in diesem Abschnitt verweisen auf ein IAM-Lernprogramm zum Erstellen einer IAM-Rolle und zum Erteilen des Zugriffs auf die Rolle. Das Tutorial bespricht auch die Übernahme einer Rolle, aber hier werden Sie stattdessen ein Auftragsskript verwenden, um die Rolle in AWS Glue anzunehmen. Dieses Tutorial enthält auch Informationen über allgemeine kontoübergreifende Praktiken. *Weitere Informationen finden Sie unter [Tutorial: AWS Kontoübergreifendes Delegieren des Zugriffs mithilfe von IAM-Rollen im IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html).*
## Erstellen einer Rolle
Folgen Sie [Schritt 1 des Tutorials](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-1), um eine IAM-Rolle in Konto A zu erstellen. Wenn Sie die Berechtigungen der Rolle definieren, können Sie festlegen, ob Sie bestehende Richtlinien anhängen möchten, z. B. DynamoDB`AmazonDynamoDBReadOnlyAccess`, oder ob die Rolle read/write DynamoDB `AmazonDynamoDBFullAccess` zugewiesen werden soll. Im folgenden Beispiel sehen Sie das Erstellen einer Rolle namens`DynamoDBCrossAccessRole`, mit der Berechtigungsrichtlinie `AmazonDynamoDBFullAccess`.
## Erteilen der Zugriffsberechtigung auf die Rolle
Befolgen Sie [Schritt 2 im Tutorial](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-2) im *IAM-Benutzerhandbuch*, damit Konto B zur neu erstellten Rolle wechseln kann. Im folgenden Beispiel wird eine neue Richtlinie mit der folgenden Anweisung erstellt:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/DynamoDBCrossAccessRole"
}
}
```
------
Anschließend können Sie diese Richtlinie an die Richtlinie anhängen, die group/role/user Sie für den Zugriff auf DynamoDB verwenden möchten.
## Übernehmen Sie die Rolle im AWS Glue-Auftragsskript
Jetzt können Sie sich bei Konto B anmelden und einen AWS Glue-Auftrag erstellen. Informationen zum Erstellen eines Auftrags finden Sie in den Anweisungen unter [Konfiguration der Auftragseigenschaften für Spark-Jobs in AWS Glue](add-job.md).
Im Job-Skript müssen Sie die `dynamodb.sts.roleArn`-Parameter verwenden, um die `DynamoDBCrossAccessRole`-Rolle anzunehmen. Wenn Sie diese Rolle annehmen, können Sie die temporären Anmeldeinformationen für den Zugriff auf DynamoDB in Konto B erhalten. Sehen Sie sich die Beispielskripts an.
Für kontenübergreifendes Lesen in verschiedenen Regionen (ETL Connector):
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-east-1",
"dynamodb.input.tableName": "test_source",
"dynamodb.sts.roleArn": ""
}
)
dyf.show()
job.commit()
```
Für kontenübergreifendes Lesen in verschiedenen Regionen (ELT Connector):
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.export": "ddb",
"dynamodb.tableArn": "",
"dynamodb.sts.roleArn": ""
}
)
dyf.show()
job.commit()
```
Für kontenübergreifendes Lesen und Schreiben in verschiedenen Regionen:
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-east-1",
"dynamodb.input.tableName": "test_source"
}
)
dyf.show()
glue_context.write_dynamic_frame_from_options(
frame=dyf,
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-west-2",
"dynamodb.output.tableName": "test_sink",
"dynamodb.sts.roleArn": ""
}
)
job.commit()
```
# DynamoDB-Konnektor mit Spark-Unterstützung DataFrame
Der DynamoDB-Konnektor mit DataFrame Spark-Unterstützung ermöglicht es Ihnen, mithilfe von Spark aus Tabellen in DynamoDB zu lesen und in Tabellen zu schreiben. DataFrame APIs [Die Schritte zur Einrichtung des Connectors sind dieselben wie für den DynamicFrame basierten Connector und finden Sie hier.](aws-glue-programming-etl-connect-dynamodb-home.md#aws-glue-programming-etl-connect-dynamodb-configure)
Um die DataFrame basierte Connector-Bibliothek zu laden, stellen Sie sicher, dass Sie eine DynamoDB-Verbindung an den Glue-Job anhängen.
**Anmerkung**
Die Benutzeroberfläche der Glue-Konsole unterstützt derzeit nicht das Erstellen einer DynamoDB-Verbindung. Sie können Glue CLI ([CreateConnection](https://docs.aws.amazon.com/cli/latest/reference/glue/create-connection.html)) verwenden, um eine DynamoDB-Verbindung herzustellen:
```
aws glue create-connection \
--connection-input '{ \
"Name": "my-dynamodb-connection", \
"ConnectionType": "DYNAMODB", \
"ConnectionProperties": {}, \
"ValidateCredentials": false, \
"ValidateForComputeEnvironments": ["SPARK"] \
}'
```
Nachdem Sie die DynamoDB-Verbindung erstellt haben, können Sie sie über CLI ([CreateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/create-job.html), [UpdateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/update-job.html)) oder direkt auf der Seite „Jobdetails“ an Ihren Glue-Job anhängen:
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/dynamodb-dataframe-connector.png)
Nachdem Sie sichergestellt haben, dass eine Verbindung mit DYNAMODB Type an Ihren Glue-Job angeschlossen ist, können Sie die folgenden Lese-, Schreib- und Exportvorgänge vom DataFrame basierten Connector aus verwenden.
## Lesen von und Schreiben in DynamoDB mit dem basierten Konnektor DataFrame
Die folgenden Codebeispiele zeigen, wie Sie über den DataFrame basierten Konnektor aus DynamoDB-Tabellen lesen und in sie schreiben. Sie demonstrieren das Lesen von einer Tabelle und das Schreiben in eine andere Tabelle.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
spark = glueContext.spark_session
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
# Read from DynamoDB
df = spark.read.format("dynamodb") \
.option("dynamodb.input.tableName", "test-source") \
.option("dynamodb.throughput.read.ratio", "0.5") \
.option("dynamodb.consistentRead", "false") \
.load()
print(df.rdd.getNumPartitions())
# Write to DynamoDB
df.write \
.format("dynamodb") \
.option("dynamodb.output.tableName", "test-sink") \
.option("dynamodb.throughput.write.ratio", "0.5") \
.option("dynamodb.item.size.check.enabled", "true") \
.save()
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val spark = glueContext.getSparkSession
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val df = spark.read
.format("dynamodb")
.option("dynamodb.input.tableName", "test-source")
.option("dynamodb.throughput.read.ratio", "0.5")
.option("dynamodb.consistentRead", "false")
.load()
print(df.rdd.getNumPartitions)
df.write
.format("dynamodb")
.option("dynamodb.output.tableName", "test-sink")
.option("dynamodb.throughput.write.ratio", "0.5")
.option("dynamodb.item.size.check.enabled", "true")
.save()
job.commit()
}
}
```
------
## Verwenden des DynamoDB-Exports über den basierten Konnektor DataFrame
Der Exportvorgang wird dem Lesevorgang für DynamoDB-Tabellen mit einer Größe von mehr als 80 GB vorgezogen. Die folgenden Codebeispiele zeigen, wie aus einer Tabelle gelesen, nach S3 exportiert und die Anzahl der Partitionen über den basierten Konnektor gedruckt wird. DataFrame
**Anmerkung**
Die DynamoDB-Exportfunktion ist über das `DynamoDBExport` Scala-Objekt verfügbar. Python-Benutzer können über das JVM-Interop von Spark darauf zugreifen oder das AWS-SDK für Python (boto3) mit der DynamoDB-API verwenden. `ExportTableToPointInTime`
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.{GlueArgParser, Job}
import org.apache.spark.SparkContext
import glue.spark.dynamodb.DynamoDBExport
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val spark = glueContext.getSparkSession
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val options = Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> "arn:aws:dynamodb:us-east-1:123456789012:table/my-table",
"dynamodb.s3.bucket" -> "my-s3-bucket",
"dynamodb.s3.prefix" -> "my-s3-prefix",
"dynamodb.simplifyDDBJson" -> "true"
)
val df = DynamoDBExport.fullExport(spark, options)
print(df.rdd.getNumPartitions)
df.count()
Job.commit()
}
}
```
------
## Konfigurationsoptionen
### Lesen Sie die Optionen
| Option | Description | Standard |
| --- | --- | --- |
| dynamodb.input.tableName | DynamoDB-Tabellenname (erforderlich) | - |
| dynamodb.throughput.read | Die zu verwendenden Lesekapazitätseinheiten (RCU). Falls nicht spezifiziert, dynamodb.throughput.read.ratio wird sie für die Berechnung verwendet. | - |
| dynamodb.throughput.read.ratio | Das Verhältnis von Lesekapazitätseinheiten (RCU) zur Nutzung | 0.5 |
| dynamodb.table.read.capacity | Die Lesekapazität der On-Demand-Tabelle, die zur Berechnung des Durchsatzes verwendet wird. Dieser Parameter ist nur in On-Demand-Kapazitätstabellen wirksam. Die Standardeinstellung ist auf Leseeinheiten mit warmem Durchsatz eingestellt. | - |
| dynamodb.splits | Definiert, wie viele Segmente bei parallel Scanvorgängen verwendet werden. Falls nicht angegeben, berechnet der Connector einen angemessenen Standardwert. | - |
| dynamodb.consistentRead | Ob stark konsistente Lesevorgänge verwendet werden sollen | FALSE |
| dynamodb.input.retry | Definiert, wie viele Wiederholungen wir durchführen, wenn es eine Ausnahme gibt, die erneut versucht werden kann. | 10 |
### Optionen schreiben
| Option | Description | Standard |
| --- | --- | --- |
| dynamodb.output.tableName | DynamoDB-Tabellenname (erforderlich) | - |
| dynamodb.throughput.write | Die zu verwendenden Schreibkapazitätseinheiten (WCU). Falls nicht angegeben, dynamodb.throughput.write.ratio wird sie für die Berechnung verwendet. | - |
| dynamodb.throughput.write.ratio | Das Verhältnis von Schreibkapazitätseinheiten (WCU) zur Nutzung | 0.5 |
| dynamodb.table.write.capacity | Die Schreibkapazität der On-Demand-Tabelle, die für die Berechnung des Durchsatzes verwendet wird. Dieser Parameter ist nur in On-Demand-Kapazitätstabellen wirksam. Standardmäßig werden Schreibeinheiten mit warmem Durchsatz verwendet. | - |
| dynamodb.item.size.check.enabled | Falls wahr, berechnet der Konnektor die Elementgröße und bricht ab, wenn die Größe die maximale Größe überschreitet, bevor er in die DynamoDB-Tabelle schreibt. | TRUE |
| dynamodb.output.retry | Definiert, wie viele Wiederholungen wir durchführen, wenn es eine Ausnahme gibt, die erneut versucht werden kann. | 10 |
### Optionen für den Export
| Option | Description | Standard |
| --- | --- | --- |
| dynamodb.export | Wenn auf gesetzt, wird der AWS Glue DynamoDB-Exportconnector ddb aktiviert, über den während des Glue-Jobs ein neuer aufgerufen ExportTableToPointInTimeRequet wird. AWS Ein neuer Export wird mit dem Speicherort generiert, der von dynamodb.s3.bucket an dynamodb.s3.prefix übergeben wurde. Wenn auf gesetzt, wird der AWS Glue DynamoDB-Exportconnector s3 aktiviert, aber die Erstellung eines neuen DynamoDB-Exports übersprungen und stattdessen dynamodb.s3.bucket and dynamodb.s3.prefix als Amazon S3 S3-Speicherort für den letzten Export dieser Tabelle verwendet. | ddb |
| dynamodb.tableArn | Die DynamoDB-Tabelle, aus der gelesen werden soll. Erforderlich, wenn dynamodb.export auf ddb festgelegt wird. | |
| dynamodb.simplifyDDBJson | Wenn auf gesetzttrue, wird eine Transformation durchgeführt, um das Schema der DynamoDB-JSON-Struktur zu vereinfachen, die in Exporten vorhanden ist. | FALSE |
| dynamodb.s3.bucket | Der S3-Bucket zum Speichern temporärer Daten während des DynamoDB-Exports (erforderlich) | |
| dynamodb.s3.prefix | Das S3-Präfix zum Speichern temporärer Daten während des DynamoDB-Exports | |
| dynamodb.s3.bucketOwner | Geben Sie den Bucket-Besitzer an, der für den kontoübergreifenden Amazon S3 S3-Zugriff benötigt wird | |
| dynamodb.s3.sse.algorithm | Art der Verschlüsselung, die für den Bucket verwendet wird, in dem temporäre Daten gespeichert werden. Gültige Werte sind AES256 und KMS. | |
| dynamodb.s3.sse.kmsKeyId | Die ID des AWS KMS verwalteten Schlüssels, der zur Verschlüsselung des S3-Buckets verwendet wird, in dem temporäre Daten gespeichert werden (falls zutreffend). | |
| dynamodb.exportTime | A, point-in-time an der der Export erfolgen soll. Gültige Werte: Zeichenketten, die ISO-8601-Instanten darstellen. | |
### Allgemeine Optionen
| Option | Description | Standard |
| --- | --- | --- |
| dynamodb.sts.roleArn | Der ARN der IAM-Rolle, der für den kontoübergreifenden Zugriff übernommen werden soll | - |
| dynamodb.sts.roleSessionName | Name der STS-Sitzung | glue-dynamodb-sts-session |
| dynamodb.sts.region | Region für den STS-Client (für regionsübergreifende Rollenübernahme) | Entspricht der Option region |
# Kinesis-Verbindungen
Sie können eine Kinesis-Verbindung verwenden, um in Amazon Kinesis Data Streams zu lesen oder zu schreiben, indem Sie Informationen nutzen, die in einer Datenkatalogtabelle gespeichert sind, oder indem Sie Informationen bereitstellen, um direkt auf den Datenstrom zuzugreifen. Sie können Informationen aus Kinesis in einen Spark einlesen DataFrame und sie dann in einen AWS Glue DynamicFrame umwandeln. Sie können in einem JSON-Format in Kinesis schreiben DynamicFrames . Wenn Sie direkt auf den Datenstrom zugreifen, verwenden Sie diese Optionen, um Informationen zum Zugriff auf den Datenstrom bereitzustellen.
Wenn Sie `getCatalogSource` oder `create_data_frame_from_catalog` verwenden, um Einträge aus einer Kinesis-Streamingquelle zu verbrauchen, enthält der Auftrag die Informationen zu Data-Catalog-Datenbank und Tabellennamen und kann diese verwenden, um einige grundlegende Parameter für das Lesen aus der Kinesis-Streaming-Quelle zu erhalten. Wenn Sie `getSource`, `getSourceWithFormat`, `createDataFrameFromOptions` oder `create_data_frame_from_options` verwenden, müssen Sie diese grundlegenden Parameter mithilfe der hier beschriebenen Verbindungsoptionen angeben.
Sie können die Verbindungsoptionen für Kinesis mit den folgenden Argumenten für die angegebenen Methoden in der `GlueContext`-Klasse angeben.
+ Scala
+ `connectionOptions`: mit `getSource`, `createDataFrameFromOptions`, `getSink` verwenden
+ `additionalOptions`: mit `getCatalogSource`, `getCatalogSink` verwenden
+ `options`: mit `getSourceWithFormat`, `getSinkWithFormat` verwenden
+ Python
+ `connection_options`: mit `create_data_frame_from_options`, `write_dynamic_frame_from_options` verwenden
+ `additional_options`: mit `create_data_frame_from_catalog`, `write_dynamic_frame_from_catalog` verwenden
+ `options`: mit `getSource`, `getSink` verwenden
Hinweise und Einschränkungen zu Streaming-ETL-Aufträgen finden Sie unter [Hinweise zu und Einschränkungen für Streaming-ETL](add-job-streaming.md#create-job-streaming-restrictions).
## Kinesis konfigurieren
Um in einem AWS Glue Spark-Job eine Verbindung zu einem Kinesis-Datenstream herzustellen, benötigen Sie einige Voraussetzungen:
+ Beim Lesen muss der AWS Glue-Job über IAM-Berechtigungen auf Lesezugriffsebene für den Kinesis-Datenstream verfügen.
+ Beim Schreiben muss der AWS Glue-Job über IAM-Berechtigungen auf Schreibzugriffsebene für den Kinesis-Datenstream verfügen.
In bestimmten Fällen müssen Sie zusätzliche Voraussetzungen konfigurieren:
+ Wenn Ihr AWS Glue-Job mit **zusätzlichen Netzwerkverbindungen** konfiguriert ist (in der Regel, um eine Verbindung zu anderen Datensätzen herzustellen) und eine dieser Verbindungen Amazon **VPC-Netzwerkoptionen bietet, leitet** dies Ihren Job an, über Amazon VPC zu kommunizieren. In diesem Fall müssen Sie auch Ihren Kinesis-Datenstrom für die Kommunikation über Amazon VPC konfigurieren. Sie können dies tun, indem Sie einen Schnittstellen-VPC-Endpunkt zwischen Ihrer Amazon VPC und dem Kinesis-Datenstrom erstellen. Weitere Informationen finden Sie unter [Verwenden von Kinesis Data Streams mit Schnittstellen-VPC-Endpunkten](https://docs.aws.amazon.com//streams/latest/dev/vpc.html).
+ Wenn Sie Amazon Kinesis Data Streams in einem anderen Konto angeben, müssen Sie die Rollen und Richtlinien einrichten, um den kontoü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).
Weitere Informationen zu den Voraussetzungen für Streaming-ETL-Aufträgen finden Sie unter [Streaming-ETL-Aufträge in AWS Glue](add-job-streaming.md).
## Beispiel: Lesen aus Kinesis-Streams
### Beispiel: Lesen aus Kinesis-Streams
Verwendet in Verbindung mit [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
Beispiel für Amazon-Kinesis-Streaming-Quelle:
```
kinesis_options =
{ "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream",
"startingPosition": "TRIM_HORIZON",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options)
```
## Beispiel: In Kinesis-Streams schreiben
### Beispiel: Lesen aus Kinesis-Streams
Verwendet in Verbindung mit [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
Beispiel für Amazon-Kinesis-Streaming-Quelle:
```
kinesis_options =
{ "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream",
"startingPosition": "TRIM_HORIZON",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options)
```
## Referenz zur Kinesis-Verbindungsoption
Bezeichnet Verbindungoptionen zu Amazon Kinesis Data Streams.
Verwenden Sie die folgenden Verbindungsoptionen für Kinesis-Streamingdatenquellen:
+ `"streamARN"` (Erforderlich) Wird zum Lesen/Schreiben verwendet. Der ARN des Kinesis-Datenstroms.
+ `"classification"` (Zum Lesen erforderlich) Wird zum Lesen verwendet. Das von den Daten im Datensatz verwendete Dateiformat. Erforderlich, sofern nicht in Data Catalog angegeben.
+ `"streamName"` – (Optional) Wird zum Lesen verwendet. Der Name eines Kinesis-Datenstroms, aus dem gelesen wird. Wird mit `endpointUrl` verwendet.
+ `"endpointUrl"` – (Optional) Wird zum Lesen verwendet. Standard: "“. https://kinesis.us-east-1.amazonaws.com Der AWS Endpunkt des Kinesis-Streams. Sie müssen dies nicht ändern, es sei denn, Sie stellen eine Verbindung zu einer bestimmten Region her.
+ `"partitionKey"` – (Optional) Wird zum Schreiben verwendet. Der Kinesis-Partitionsschlüssel, der bei der Erstellung von Datensätzen verwendet wird.
+ `"delimiter"` (Optional) Wird zum Lesen verwendet. Das verwendete Werttrennzeichen, wenn `classification` CSV ist. Der Standardwert ist „`,`„.
+ `"startingPosition"`: (Optional) Wird zum Lesen verwendet. Die Ausgangsposition im Kinesis Data Stream, von dem Daten gelesen werden sollen. Die möglichen Werte sind `"latest"`, `"trim_horizon"`, `"earliest"` oder eine Zeitstempelzeichenfolge im UTC-Format im Muster `yyyy-mm-ddTHH:MM:SSZ` (wobei `Z` einen UTC-Zeitzonenversatz mit einem \$1/- darstellt. Zum Beispiel „2023-04-04T08:00:00-04:00“). Der Standardwert ist `"latest"`. Hinweis: Die Timestamp-Zeichenfolge im UTC-Format für `"startingPosition"` wird nur für AWS Glue Version 4.0 oder höher unterstützt.
+ `"failOnDataLoss"`: (Optional) Lassen Sie den Auftrag fehlschlagen, wenn ein aktiver Shard fehlt oder abgelaufen ist. Der Standardwert ist `"false"`.
+ `"awsSTSRoleARN"`: (Optional) Wird zum Schreiben/Lesen verwendet. Der Amazon-Ressourcenname (ARN) der Rolle, die mithilfe von AWS -Security-Token-Service (AWS STS) übernommen werden soll. Diese Rolle muss über Berechtigungen zum Beschreiben oder Lesen von Datensatzoperationen für den Kinesis-Datenstrom verfügen. Sie müssen diesen Parameter verwenden, wenn Sie auf einen Datenstrom in einem anderen Konto zugreifen. Verwendet in Verbindung mit `"awsSTSSessionName"`.
+ `"awsSTSSessionName"`: (Optional) Wird zum Schreiben/Lesen verwendet. Ein Bezeichner für die Sitzung, die die Rolle unter Verwendung von AWS STSübernimmt. Sie müssen diesen Parameter verwenden, wenn Sie auf einen Datenstrom in einem anderen Konto zugreifen. Verwendet in Verbindung mit `"awsSTSRoleARN"`.
+ `"awsSTSEndpoint"`: (Optional) Der AWS STS Endpunkt, der verwendet werden soll, wenn eine Verbindung zu Kinesis mit einer angenommenen Rolle hergestellt wird. Dies ermöglicht die Verwendung des regionalen AWS STS Endpunkts in einer VPC, was mit dem globalen Standardendpunkt nicht möglich ist.
+ `"maxFetchTimeInMs"`: (Optional) Wird zum Lesen verwendet. Die maximale Zeit, die der Auftrags-Executor zum Lesen der Datensätze für den aktuellen Batch aus dem Kinesis-Datenstrom benötigt, angegeben in Millisekunden (ms). Innerhalb dieser Zeit können mehrere `GetRecords`-API-Aufrufe getätigt werden. Der Standardwert ist `1000`.
+ `"maxFetchRecordsPerShard"`: (Optional) Wird zum Lesen verwendet. Die maximale Anzahl von Datensätzen, die pro Shard im Kinesis-Datenstrom pro Microbatch abgerufen werden sollen. Hinweis: Der Client kann dieses Limit überschreiten, wenn der Streaming-Auftrag bereits zusätzliche Datensätze von Kinesis gelesen hat (im selben get-records-Aufruf). Wenn `maxFetchRecordsPerShard` streng sein muss, muss es ein Vielfaches von `maxRecordPerRead` sein. Der Standardwert ist `100000`.
+ `"maxRecordPerRead"`: (Optional) Wird zum Lesen verwendet. Die maximale Anzahl von Datensätzen, die bei jeder `getRecords`-Operation aus dem Kinesis-Datenstrom abgerufen werden sollen. Der Standardwert ist `10000`.
+ `"addIdleTimeBetweenReads"`: (Optional) Wird zum Lesen verwendet. Fügt eine Zeitverzögerung zwischen zwei aufeinanderfolgenden `getRecords`-Operationen ein. Der Standardwert ist `"False"`. Diese Option ist nur für Glue 2.0 und höher konfigurierbar.
+ `"idleTimeBetweenReadsInMs"`: (Optional) Wird zum Lesen verwendet. Die minimale Zeitverzögerung zwischen zwei aufeinanderfolgenden `getRecords`-Operationen, angegeben in Millisekunden (ms). Der Standardwert ist `1000`. Diese Option ist nur für Glue 2.0 und höher konfigurierbar.
+ `"describeShardInterval"`: (Optional) Wird zum Lesen verwendet. Das minimale Zeitintervall zwischen zwei `ListShards`-API-Aufrufen für die Erwägung eines erneuten Shardings durch Ihr Skript. Weitere Informationen finden Sie unter [Strategies for Resharding (Strategien für das Resharding)](https://docs.aws.amazon.com//streams/latest/dev/kinesis-using-sdk-java-resharding-strategies.html) im *Entwicklerhandbuch für Amazon Kinesis Data Streams*. Der Standardwert ist `1s`.
+ `"numRetries"`: (Optional) Wird zum Lesen verwendet. Die maximale Anzahl erneuter Versuche für API-Aufrufe von Kinesis Data Streams. Der Standardwert ist `3`.
+ `"retryIntervalMs"`: (Optional) Wird zum Lesen verwendet. Die Abkühlzeit (angegeben in ms) vor dem erneuten Versuch des API-Aufrufs von Kinesis Data Streams. Der Standardwert ist `1000`.
+ `"maxRetryIntervalMs"`: (Optional) Wird zum Lesen verwendet. Die maximale Abkühlzeit (angegeben in ms) zwischen zwei wiederholten Versuchen eines API-Aufrufs von Kinesis Data Streams. Der Standardwert ist `10000`.
+ `"avoidEmptyBatches"`: (Optional) Wird zum Lesen verwendet. Vermeidet das Erstellen eines leeren Mikrobatchauftrags, indem vor dem Start des Batches im Kinesis Data Stream nach ungelesenen Daten gesucht wird. Der Standardwert ist `"False"`.
+ `"schema"`: (Erforderlich, wenn inferSchema auf „false“ festgelegt ist) Wird zum Lesen verwendet. Das zu verwendende Schema für die Verarbeitung der Nutzlast. Wenn die Klassifizierung `avro` ist, muss das bereitgestellte Schema im Avro-Schemaformat vorliegen. Wenn die Klassifizierung nicht `avro` ist, muss das bereitgestellte Schema im DDL-Schemaformat vorliegen.
Im Folgenden finden Sie Beispiele für Schemata.
------
#### [ Example in DDL schema format ]
```
`column1` INT, `column2` STRING , `column3` FLOAT
```
------
#### [ Example in Avro schema format ]
```
{
"type":"array",
"items":
{
"type":"record",
"name":"test",
"fields":
[
{
"name":"_id",
"type":"string"
},
{
"name":"index",
"type":
[
"int",
"string",
"float"
]
}
]
}
}
```
------
+ `"inferSchema"`: (Optional) Wird zum Lesen verwendet. Der Standardwert von "false". Wenn auf „true“ gesetzt, wird das Schema zur Laufzeit von der Nutzlast in `foreachbatch` erkannt.
+ `"avroSchema"`: (Veraltet) Wird zum Lesen verwendet. Der Parameter, der verwendet wird, um ein Schema von Avro-Daten anzugeben, wenn das Avro-Format verwendet wird. Dieser Parameter ist jetzt veraltet. Verwenden Sie den Parameter `schema`.
+ `"addRecordTimestamp"`: (Optional) Wird zum Lesen verwendet. Wenn diese Option auf 'true' gesetzt ist, enthält die Datenausgabe eine zusätzliche Spalte mit dem Namen „\$1\$1src\$1timestamp“, die die Uhrzeit angibt, zu der der entsprechende Datensatz mit dem Stream empfangen wurde. Der Standardwert von "false". Diese Option wird in AWS Glue Version 4.0 oder höher unterstützt.
+ `"emitConsumerLagMetrics"`: (Optional) Wird zum Lesen verwendet. Wenn die Option auf „true“ gesetzt ist, werden für jeden Batch die Metriken für den Zeitraum zwischen dem ältesten Datensatz, der vom Stream empfangen wurde, und dem Zeitpunkt, AWS Glue zu CloudWatch dem er eingeht, ausgegeben. Der Name der Metrik lautet „glue.driver.streaming“. maxConsumerLagInMs“. Der Standardwert von "false". Diese Option wird in AWS Glue Version 4.0 oder höher unterstützt.
+ `"fanoutConsumerARN"`: (Optional) Wird zum Lesen verwendet. Der ARN eines Kinesis-Stream-Verbrauchers für den in `streamARN` angegebenen Stream. Wird verwendet, um den erweiterten Fan-Out-Modus für Ihre Kinesis-Verbindung zu aktivieren. Weitere Informationen zur Nutzung eines Kinesis-Streams mit erweitertem Fan-Out finden Sie unter [Verwendung von erweitertem Fan-Out in Kinesis-Streaming-Aufträgen](aws-glue-programming-etl-connect-kinesis-efo.md).
+ `"recordMaxBufferedTime"` – (Optional) Wird zum Schreiben verwendet. Standard: 1.000 (ms). Maximale Dauer, für die ein Datensatz gepuffert wird, während er darauf wartet, geschrieben zu werden.
+ `"aggregationEnabled"` – (Optional) Wird zum Schreiben verwendet. Standard: true Gibt an, ob Datensätze aggregiert werden sollen, bevor sie an Kinesis gesendet werden.
+ `"aggregationMaxSize"` – (Optional) Wird zum Schreiben verwendet. Standard: 51.200 (Byte). Wenn ein Datensatz dieses Limit übersteigt, wird der Aggregator umgangen. Hinweis Kinesis erzwingt ein Limit von 50 KB für die Größe eines Datensatzes. Wenn Sie diesen Wert auf mehr als 50 KB festlegen, werden übergroße Datensätze von Kinesis zurückgewiesen.
+ `"aggregationMaxCount"` – (Optional) Wird zum Schreiben verwendet. Standard: 4.294.967.295. Maximale Anzahl von Elementen, die in einen aggregierten Datensatz gepackt werden sollen.
+ `"producerRateLimit"` – (Optional) Wird zum Schreiben verwendet. Standard: 150 (%). Beschränkt den Durchsatz pro Shard, der von einem einzelnen Produzenten (z. B. Ihrem Auftrag) gesendet wird, als prozentualen Wert des Backend-Limits.
+ `"collectionMaxCount"` – (Optional) Wird zum Schreiben verwendet. Standard: 500. Maximale Anzahl von Artikeln, die in eine PutRecords Anfrage gepackt werden sollen.
+ `"collectionMaxSize"` – (Optional) Wird zum Schreiben verwendet. Standard: 5.242.880 (Byte). Maximale Datenmenge, die mit einer PutRecords Anfrage gesendet werden kann.
# Verwendung von erweitertem Fan-Out in Kinesis-Streaming-Aufträgen
Ein erweiterter Fan-Out-Verbraucher kann Datensätze von einem Kinesis-Stream mit einem dedizierten Durchsatz empfangen, der größer sein kann als bei typischen Anwendern. Dies erfolgt durch die Optimierung des Übertragungsprotokolls, das zur Bereitstellung von Daten an einen Kinesis-Verbraucher, beispielsweise Ihren Auftrag, verwendet wird. Weitere Informationen zu Kinesis Enhanced Fan-Out finden Sie in der [Kinesis-Dokumentation](https://docs.aws.amazon.com//streams/latest/dev/enhanced-consumers.html).
Im erweiterten Fan-Out-Modus gelten die `maxRecordPerRead`- und `idleTimeBetweenReadsInMs`-Verbindungsoptionen nicht mehr, da diese Parameter bei Verwendung des erweiterten Fan-Outs nicht konfigurierbar sind. Die Konfigurationsoptionen für Wiederholungsversuche funktionieren wie beschrieben.
Verwenden Sie die folgenden Verfahren, um das erweiterte Fanout für Ihren Streaming-Auftrag zu aktivieren und zu deaktivieren. Sie sollten für jeden Auftrag, der Daten aus Ihrem Stream konsumiert, einen Stream-Anwender registrieren.
**So aktivieren Sie einen verbesserten Fan-Out-Verbrauch für Ihren Auftrag:**
1. Registrieren Sie mithilfe der Kinesis-API einen Stream-Verbraucher für Ihren Auftrag. Befolgen Sie die Anweisungen zum *Registrieren eines Verbrauchers mit erweitertem Fan-Out mithilfe der Kinesis-Data-Streams-API* in der [Kinesis-Dokumentation](https://docs.aws.amazon.com//streams/latest/dev/building-enhanced-consumers-api). Sie müssen nur dem ersten Schritt folgen - dem Anrufen [RegisterStreamConsumer](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RegisterStreamConsumer.html). Ihre Anfrage sollte einen ARN zurückgeben,*consumerARN*.
1. Stellen Sie die Verbindungsoption *consumerARN* in `fanoutConsumerARN` Ihren Argumenten für die Verbindungsmethode auf ein.
1. Starten Sie Ihren Auftrag neu.
**So deaktivieren Sie den erweiterten Fanout-Verbrauch für Ihren Auftrag:**
1. Entfernen Sie die `fanoutConsumerARN`-Verbindungsoption aus Ihrem Methodenaufruf.
1. Starten Sie Ihren Auftrag neu.
1. Befolgen Sie die Anweisungen zum *Abmelden eines Verbrauchers* in der [Kinesis-Dokumentation](https://docs.aws.amazon.com/streams/latest/dev/building-enhanced-consumers-console.html). Diese Anweisungen gelten für die Konsole, können aber auch über die Kinesis-API erreicht werden. Weitere Informationen zur Abmeldung von Stream-Consumer über die Kinesis-API finden Sie [DeregisterStreamConsumer](https://docs.aws.amazon.com//kinesis/latest/APIReference/API_DeregisterStreamConsumer.html)in der Kinesis-Dokumentation.
# Amazon-S3-Verbindungen
Sie können AWS Glue for Spark verwenden, um Dateien in Amazon S3 zu lesen und zu schreiben. AWS Glue for Spark unterstützt viele gängige Datenformate, die standardmäßig in Amazon S3 gespeichert sind, darunter CSV, Avro, JSON, Orc und Parquet. Weitere Informationen zu unterstützten Datenformaten finden Sie unter [Mögliche Formate für Eingaben und Ausgaben in AWS Glue für Spark](aws-glue-programming-etl-format.md). Jedes Datenformat unterstützt möglicherweise einen anderen Satz von AWS Glue-Funktionen. Informieren Sie sich auf der Seite für Ihr Datenformat über die Besonderheiten der Feature-Unterstützung. Darüber hinaus können Sie versionierte Dateien lesen und schreiben, die in den Data-Lake-Frameworks Hudi, Iceberg und Delta Lake gespeichert sind. Weitere Informationen zu Data Lake-Frameworks finden Sie unter [Verwendung von Data-Lake-Frameworks mit AWS Glue ETL-Jobs](aws-glue-programming-etl-datalake-native-frameworks.md).
Mit AWS Glue können Sie Ihre Amazon S3 S3-Objekte beim Schreiben in eine Ordnerstruktur partitionieren und sie dann partitionsweise abrufen, um die Leistung mithilfe einer einfachen Konfiguration zu verbessern. Sie können die Konfiguration auch so festlegen, dass kleine Dateien beim Transformieren Ihrer Daten gruppiert werden, um die Leistung zu verbessern. Sie können in Amazon S3 lesen, `bzip2` schreiben und `gzip` archivieren.
**Topics**
+ [Konfiguration von S3-Verbindungen](#aws-glue-programming-etl-connect-s3-configure)
+ [Referenz zur Amazon-S3-Verbindungsoption](#aws-glue-programming-etl-connect-s3)
+ [Veraltete Verbindungssyntaxen für Datenformate](#aws-glue-programming-etl-connect-legacy-format)
+ [Ausschließen von Amazon-S3-Speicherklassen](aws-glue-programming-etl-storage-classes.md)
+ [Verwalten von Partitionen für die ETL-Ausgabe in AWS Glue](aws-glue-programming-etl-partitions.md)
+ [Zusammenfassen von Eingabedateien in größeren Gruppen beim Lesen](grouping-input-files.md)
+ [Amazon-VPC-Endpunkte für Amazon S3](vpc-endpoints-s3.md)
## Konfiguration von S3-Verbindungen
Um in einem AWS Glue with Spark-Job eine Verbindung zu Amazon S3 herzustellen, benötigen Sie einige Voraussetzungen:
+ Der AWS Glue-Job muss über IAM-Berechtigungen für relevante Amazon S3 S3-Buckets verfügen.
In bestimmten Fällen müssen Sie zusätzliche Voraussetzungen konfigurieren:
+ Bei der Konfiguration des kontoübergreifenden Zugriffs sind entsprechende Zugriffskontrollen für den Amazon-S3-Bucket erforderlich.
+ Aus Sicherheitsgründen können Sie Ihre Amazon-S3-Anfragen über eine Amazon VPC weiterleiten. Dieser Ansatz kann zu Herausforderungen in Bezug auf Bandbreite und Verfügbarkeit führen. Weitere Informationen finden Sie unter [Amazon-VPC-Endpunkte für Amazon S3](vpc-endpoints-s3.md).
## Referenz zur Amazon-S3-Verbindungsoption
Bezeichnet eine Verbindung mit Amazon S3.
Da Amazon S3 Dateien und nicht Tabellen verwaltet, müssen Sie zusätzlich zur Angabe der in diesem Dokument bereitgestellten Verbindungseigenschaften auch zusätzliche Konfigurationen für Ihren Dateityp angeben. Sie geben diese Informationen über Datenformatoptionen an. Weitere Informationen zu den Formatoptionen finden Sie unter [Mögliche Formate für Eingaben und Ausgaben in AWS Glue für Spark](aws-glue-programming-etl-format.md). Sie können diese Informationen auch durch die Integration mit dem AWS Glue Data Catalog angeben.
Betrachten Sie als Beispiel für die Unterscheidung zwischen Verbindungsoptionen und Formatoptionen die Art und Weise, wie die [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options)-Methode `connection_type`, `connection_options`, `format` und `format_options` verwendet. In diesem Abschnitt werden speziell die für `connection_options` bereitgestellten Parameter erläutert.
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "s3"`:
+ `"paths"`: (Erforderlich) Eine Liste der Amazon-S3-Pfade, aus denen gelesen werden soll.
+ `"exclusions"`: (Optional) Eine Zeichenfolge, die eine JSON-Liste der auszuschließenden Glob-Muster im Unix-Stil enthält. Beispiel: `"[\"**.pdf\"]"` schließt alle PDF-Dateien aus. Weitere Informationen zur Glob-Syntax, die AWS Glue unterstützt, finden Sie unter [Include- und Exclude-Muster](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude).
+ `"compressionType"` oder "`compression`": (Optional) Gibt an, wie die Daten komprimiert werden. Verwenden von `"compressionType"` für Amazon-S3-Quellen und `"compression"` für Amazon-S3-Ziele. Dies ist in der Regel nicht notwendig, wenn die Daten eine Standard-Dateierweiterung haben. Mögliche Werte sind `"gzip"` und `"bzip2"`). Für bestimmte Formate werden möglicherweise zusätzliche Komprimierungsformate unterstützt. Einzelheiten zur Feature-Unterstützung finden Sie auf der Seite zum Datenformat.
+ `"groupFiles"`: (Optional) Die Gruppierung von Dateien ist standardmäßig aktiviert, wenn die Eingabe mehr als 50 000 Dateien enthält. Um die Gruppierung mit weniger als 50 000 Dateien zu aktivieren, setzen Sie diesen Parameter auf `"inPartition"`. Um die Gruppierung zu deaktivieren, wenn mehr als 50 000 Dateien vorhanden sind, setzen Sie diesen Parameter auf `"none"`.
+ `"groupSize"`: (Optional) Die Größe der Zielgruppe in Bytes. Der Standardwert wird anhand der Größe der Eingabedaten und der Größe des Clusters berechnet. Wenn es weniger als 50 000 Eingabedateien gibt, muss `"groupFiles"` auf `"inPartition"` gesetzt werden, damit dies wirksam wird.
+ `"recurse"`: (Optional) Wenn auf true gesetzt, werden Dateien in allen Unterverzeichnissen unter den angegebenen Pfaden rekursiv gelesen.
+ `"maxBand"`: (Optional, erweitert) – Diese Option steuert die Dauer in Millisekunden, nach der die `s3`-Auflistung wahrscheinlich konsistent ist. Dateien mit Änderungszeitstempeln, die innerhalb der letzten `maxBand` Millisekunden liegen, werden vor allem bei der Verwendung von `JobBookmarks` zur Berücksichtigung der letztendlichen Konsistenz von Amazon S3 verfolgt. Die meisten Benutzer müssen diese Option nicht festlegen. Der Standardwert ist 900 000 Millisekunden oder 15 Minuten
+ `"maxFilesInBand"`: (Optional, erweitert) – Diese Option gibt die maximale Anzahl von Dateien an, die aus den letzten `maxBand` Sekunden gespeichert werden sollen. Wird diese Anzahl überschritten, werden zusätzliche Dateien übersprungen und erst bei der nächsten Auftragsausführung verarbeitet. Die meisten Benutzer müssen diese Option nicht festlegen.
+ `"isFailFast"`: (Optional) Diese Option bestimmt, ob ein AWS Glue-ETL-Auftrag Reader-Parsing-Ausnahmen ausgibt. Wenn `true`, schlagen Aufträge schnell fehl, wenn vier Wiederholungen der Spark-Aufgabe die Daten nicht korrekt parsen.
+ `"catalogPartitionPredicate"`: (Optional) Wird zum Lesen verwendet. Der Inhalt einer SQL-`WHERE`-Klausel. Wird beim Lesen aus Data-Catalog-Tabellen mit einer sehr großen Anzahl von Partitionen verwendet. Ruft passende Partitionen aus Data-Catalog-Indizes ab. Wird mit `push_down_predicate`, einer Option der [create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog)-Methode (und anderen ähnlichen Methoden) verwendet. Weitere Informationen finden Sie unter [Serverseitige Filterung mit Katalogpartitionsprädikaten](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates).
+ `"partitionKeys"`: (Optional) Wird zum Schreiben verwendet. Ein Array von Zeichenketten mit Spaltenbezeichnungen. AWS Glue partitioniert Ihre Daten wie in dieser Konfiguration angegeben. Weitere Informationen finden Sie unter [Schreiben von Partitionen](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-writing).
+ `"excludeStorageClasses"`: (Optional) Wird zum Lesen verwendet. Ein Array von Zeichenketten, die Amazon S3 S3-Speicherklassen angeben. AWS Glue schließt Amazon S3 S3-Objekte basierend auf dieser Konfiguration aus. Weitere Informationen finden Sie unter [Ausschließen von Amazon-S3-Speicherklassen](aws-glue-programming-etl-storage-classes.md).
## Veraltete Verbindungssyntaxen für Datenformate
Auf bestimmte Datenformate kann mithilfe einer bestimmten Verbindungstyp-Syntax zugegriffen werden. Diese Syntax ist veraltet. Wir empfehlen Ihnen, Ihre Formate stattdessen mithilfe des `s3`-Verbindungstyps und der in [Mögliche Formate für Eingaben und Ausgaben in AWS Glue für Spark](aws-glue-programming-etl-format.md) bereitgestellten Formatoptionen anzugeben.
### "connectionType": "orc"
Bezeichnet eine Verbindung zu Dateien, die in Amazon S3 im Dateiformat [Apache Hive Optimized Row Columnar (ORC)](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC) gespeichert sind.
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "orc"`:
+ `paths`: (Erforderlich) Eine Liste der Amazon-S3-Pfade, aus denen gelesen werden soll.
+ *(Andere name/value Optionspaare)*: Alle zusätzlichen Optionen, einschließlich Formatierungsoptionen, werden direkt an SparkSQL übergeben. `DataSource`
### "connectionType": "parquet"
Bezeichnet eine Verbindung mit Dateien, die in Amazon S3 im Dateiformat [Apache Parquet](https://parquet.apache.org/docs/) gespeichert sind.
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "parquet"`:
+ `paths`: (Erforderlich) Eine Liste der Amazon-S3-Pfade, aus denen gelesen werden soll.
+ *(Andere name/value Optionspaare)*: Alle zusätzlichen Optionen, einschließlich Formatierungsoptionen, werden direkt an SparkSQL übergeben. `DataSource`
# Ausschließen von Amazon-S3-Speicherklassen
Wenn Sie AWS Glue-ETL-Aufträge ausführen, die Dateien oder Partitionen aus Amazon Simple Storage Service (Amazon S3) lesen, können Sie einige Amazon-S3-Speicherklassentypen ausschließen.
Die folgenden Speicherklassen sind in Amazon S3 verfügbar:
+ `STANDARD` – Für die universelle Speicherung häufig aufgerufener Daten.
+ `INTELLIGENT_TIERING` – Für Daten mit wechselnden oder unbekannten Zugriffsmustern.
+ `STANDARD_IA` und `ONEZONE_IA` – Für langlebige Daten, auf die weniger häufig zugegriffen wird.
+ `GLACIER`, `DEEP_ARCHIVE` und `REDUCED_REDUNDANCY` – Für die Langzeitarchivierung und digitale Archivierung.
Weitere Informationen finden Sie unter [Amazon S3 Storage Classes (Amazon-S3-Speicherklassen)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html) im *Amazon-S3-Entwicklerhandbuch*.
Die Beispiele in diesem Abschnitt zeigen, wie Sie die `GLACIER`- und `DEEP_ARCHIVE`-Speicherklassen ausschließen. Mit diesen Klassen können Sie Dateien auflisten, aber Sie können die Dateien nur lesen, wenn sie wiederhergestellt werden. (Weitere Informationen finden Sie unter [Restoring Archived Objects (Wiederherstellen archivierter Objekte)](https://docs.aws.amazon.com/AmazonS3/latest/dev/restoring-objects.html) im *Amazon-S3-Entwicklerhandbuch*.)
Durch die Verwendung von Speicherklassenausschlüssen können Sie sicherstellen, dass Ihre AWS Glue-Aufträge für Tabellen funktionieren, die über Partitionen in diesen Speicherklassenstufen verfügen. Ohne Ausnahmen schlagen Aufträge, die Daten aus diesen Stufen lesen, mit dem folgenden Fehler fehl: AmazonS3Exception: The operation is not valid for the object storage class.
Es gibt verschiedene Möglichkeiten, Amazon-S3-Speicherklassen in AWS Glue zu filtern.
**Topics**
+ [Ausschließen von Amazon-S3-Speicherklassen beim Erstellen eines Dynamic Frames](#aws-glue-programming-etl-storage-classes-dynamic-frame)
+ [Ausschließen von Amazon-S3-Speicherklassen in einer Data-Catalog-Tabelle](#aws-glue-programming-etl-storage-classes-table)
## Ausschließen von Amazon-S3-Speicherklassen beim Erstellen eines Dynamic Frames
Um Amazon S3-Speicherklassen beim Erstellen eines dynamischen Frames auszuschließen, verwenden Sie `excludeStorageClasses` in `additionalOptions`. AWS Glue verwendet automatisch eine eigene Amazon S3 `Lister`-Implementierung, um Dateien aufzulisten und auszuschließen, die den angegebenen Speicherklassen entsprechen.
Die folgenden Python- und Scala-Beispiele zeigen, wie Sie die Speicherklassen `GLACIER` und `DEEP_ARCHIVE` beim Erstellen eines Dynamic Frames ausschließen.
Python-Beispiel:
```
glueContext.create_dynamic_frame.from_catalog(
database = "my_database",
tableName = "my_table_name",
redshift_tmp_dir = "",
transformation_ctx = "my_transformation_context",
additional_options = {
"excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
}
)
```
Scala-Beispiel:
```
val* *df = glueContext.getCatalogSource(
nameSpace, tableName, "", "my_transformation_context",
additionalOptions = JsonOptions(
Map("excludeStorageClasses" -> List("GLACIER", "DEEP_ARCHIVE"))
)
).getDynamicFrame()
```
## Ausschließen von Amazon-S3-Speicherklassen in einer Data-Catalog-Tabelle
Sie können Speicherklassenausschlüsse, die von einem AWS Glue ETL-Job verwendet werden sollen, als Tabellenparameter im AWS Glue-Datenkatalog angeben. Sie können diesen Parameter mithilfe von AWS Command Line Interface (AWS CLI) oder programmgesteuert mithilfe der API in den `CreateTable` Vorgang einbeziehen. Weitere Informationen finden Sie unter [Tabellenstruktur](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-Table) und. [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)
Sie können auch ausgeschlossene Speicherklassen in der AWS Glue-Konsole angeben.
**Ausschließen von Amazon-S3-Speicherklassen (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Wählen Sie im Navigationsbereich auf der linken Seite **Tabellen** aus.
1. Wählen Sie den Tabellennamen in der Liste aus und klicken Sie dann auf **Edit table (Tabelle bearbeiten)**.
1. Fügen Sie unter **Table properties (Tabelleneigenschaften)** **excludeStorageClasses** als Schlüssel und **[\$1"GLACIER\$1",\$1"DEEP\$1ARCHIVE\$1"]** als Wert hinzu.
1. Wählen Sie **Anwenden** aus.
# Verwalten von Partitionen für die ETL-Ausgabe in AWS Glue
Die Partitionierung ist eine wichtige Methode zum Organisieren von Datasets, sodass diese effizient abgefragt werden können. Sie ordnet Daten basierend auf den individuellen Werten einer oder mehrerer Spalten in eine hierarchische Verzeichnisstruktur.
Beispiel: Sie können Ihre Anwendungsprotokolle in Amazon Simple Storage Service (Amazon S3) nach Datum, aufgeschlüsselt nach Jahr, Monat und Tag, partitionieren. Dateien, die der Datenmenge eines einzelnen Tages entsprechen, werden dann unter einem Präfix wie `s3://my_bucket/logs/year=2018/month=01/day=23/` geordnet. Systeme wie Amazon Athena, Amazon Redshift Spectrum und nun auch AWS Glue können diese Partitionen zum Filtern von Daten nach Partitionswert verwenden, ohne die zugrunde liegenden Daten aus Amazon S3 lesen zu müssen.
Crawler leiten nicht nur Dateitypen und Schemas ab, sie identifizieren auch automatisch die Partitionsstruktur Ihres Datensatzes, wenn sie den AWS Glue-Datenkatalog füllen. Die resultierenden Partitionsspalten stehen für das Abfragen von ETL-Aufträgen in AWS Glue oder das Abfragen von Engines wie Amazon Athena zur Verfügung.
Nachdem Sie eine Tabelle durchsucht haben, können Sie die Partitionen anzeigen, die vom Crawler erstellt wurden. Wählen Sie im linken Navigationsbereich der AWS Glue-Konsole **Tables (Tabellen)** aus. Wählen Sie die vom Crawler erstellte Tabelle und dann **View Partitions (Partionen anzeigen)** aus.
Für Apache Hive-ähnliche partitionierte Pfade im `key=val`-Stil füllen Crawler den Spaltennamen automatisch mit dem Schlüsselnamen. Andernfalls werden Standardnamen wie z. B. `partition_0`, `partition_1` usw. verwendet. Sie können die Standardnamen in der Konsole ändern. Navigieren Sie dazu zur Tabelle. Überprüfen Sie, ob Indizes auf der Registerkarte **Indizes** vorhanden sind. Wenn das der Fall ist, müssen Sie sie löschen, um fortzufahren (Sie können sie anschließend mit den neuen Spaltennamen neu erstellen). Wählen Sie dann **Schema bearbeiten** und ändern Sie dort die Namen der Partitionsspalten.
In Ihren ETL-Skripts können Sie dann die Partitionsspalten filtern. Da die Partitionsinformationen im Data Catalog gespeichert sind, verwenden Sie die `from_catalog`-API-Aufrufe, um die Partitionsspalten in `DynamicFrame` zu erfassen. Verwenden Sie z. B. `create_dynamic_frame.from_catalog` statt `create_dynamic_frame.from_options`.
Partitionierung ist eine Optimierungsmethode, die zu einer geringeren Menge an gescannten Daten führt. Weitere Informationen darüber, wie Sie feststellen können, wann diese Technik geeignet ist, finden Sie unter [Reduce the amount of data scan](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/reduce-data-scan.html) im Leitfaden *Best Practices for Performance Tuning AWS Glue for Apache Spark Jobs* auf AWS Prescriptive Guidance.
## Vorabfilterung mit Pushdown-Prädikaten
In vielen Fällen können Sie ein Pushdown-Prädikat zum Filtern von Partitionen verwenden, ohne alle Dateien Ihres Datasets auflisten und lesen zu müssen. Anstatt den gesamten Datensatz zu lesen und dann in einem zu filtern DynamicFrame, können Sie den Filter direkt auf die Metadaten der Partition im Datenkatalog anwenden. Dann listen Sie nur auf und lesen in eine ein, was Sie tatsächlich benötigen DynamicFrame.
In Python können Sie beispielsweise Folgendes schreiben:
```
glue_context.create_dynamic_frame.from_catalog(
database = "my_S3_data_set",
table_name = "catalog_data_table",
push_down_predicate = my_partition_predicate)
```
Dadurch wird eine erstellt DynamicFrame , die nur die Partitionen im Datenkatalog lädt, die dem Prädikatausdruck entsprechen. Je nachdem, wie klein eine Teilmenge der Daten ist, die Sie laden, kann dies sehr viel Verarbeitungszeit sparen.
Der Prädikatausdruck kann ein beliebiger boolescher Ausdruck sein, der von Spark SQL unterstützt wird. Alles, was Sie in eine `WHERE`-Klausel einer Spark SQL-Abfrage aufnehmen können, wird unterstützt. Beispiel: Mit dem Prädikatausdruck `pushDownPredicate = "(year=='2017' and month=='04')"` werden nur die Partitionen in den Data Catalog geladen, die sowohl `year` gleich 2017 und `month` gleich 04 ist. Weitere Informationen finden Sie in der [Apache Spark SQL-Dokumentation](https://spark.apache.org/docs/2.1.1/sql-programming-guide.html) und insbesondere in der [Scala SQL-Funktionsreferenz](https://spark.apache.org/docs/2.1.1/api/scala/index.html#org.apache.spark.sql.functions$).
## Serverseitige Filterung mit Katalogpartitionsprädikaten
Die Option `push_down_predicate` wird angewendet, nachdem alle Partitionen aus dem Katalog aufgelistet wurden und bevor Dateien von Amazon S3 für diese Partitionen angeboten werden. Wenn Sie viele Partitionen für eine Tabelle haben, kann die Liste der Katalogpartitionen immer noch zusätzlichen Zeitaufwand verursachen. Um diesen Mehraufwand zu beheben, können Sie serverseitiges Partitionsbereinigen mit der `catalogPartitionPredicate` Option verwenden, die [Partitionsindizes](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) im AWS Glue-Datenkatalog verwendet. Dies macht die Partitionsfilterung viel schneller, wenn Millionen von Partitionen in einer Tabelle vorhanden sind. Sie können sowohl `push_down_predicate` und `catalogPartitionPredicate` in `additional_options` zusammen verwenden, wenn Ihr `catalogPartitionPredicate` eine Prädikatsyntax erfordert, die noch nicht von den Katalogpartition-Indizes unterstützt wird.
Python:
```
dynamic_frame = glueContext.create_dynamic_frame.from_catalog(
database=dbname,
table_name=tablename,
transformation_ctx="datasource0",
push_down_predicate="day>=10 and customer_id like '10%'",
additional_options={"catalogPartitionPredicate":"year='2021' and month='06'"}
)
```
Scala:
```
val dynamicFrame = glueContext.getCatalogSource(
database = dbname,
tableName = tablename,
transformationContext = "datasource0",
pushDownPredicate="day>=10 and customer_id like '10%'",
additionalOptions = JsonOptions("""{
"catalogPartitionPredicate": "year='2021' and month='06'"}""")
).getDynamicFrame()
```
**Anmerkung**
`push_down_predicate` und `catalogPartitionPredicate` verwenden verschiedene Syntaxen. Erstere verwendet die Spark-SQL-Standardsyntax und letztere verwendet den JSQL-Parser.
## Schreiben von Partitionen
Standardmäßig DynamicFrame ist a beim Schreiben nicht partitioniert. Alle Ausgabedateien werden auf der obersten Ebene des angegebenen Ausgabepfads geschrieben. Bis vor Kurzem bestand die einzige Möglichkeit, eine DynamicFrame in Partitionen zu schreiben, darin, sie DataFrame vor dem Schreiben in eine Spark-SQL zu konvertieren.
Unterstützt DynamicFrames jetzt jedoch die native Partitionierung mit einer Tastenfolge, indem Sie die `partitionKeys` Option verwenden, wenn Sie eine Senke erstellen. Der folgende Python-Code schreibt beispielsweise in Amazon S3 einen Datensatz im Parquet-Format in Verzeichnisse, die nach dem Type-Feld partitioniert sind. Von dort aus können Sie diese Partitionen mit anderen Systemen wie Amazon Athena verarbeiten.
```
glue_context.write_dynamic_frame.from_options(
frame = projectedEvents,
connection_type = "s3",
connection_options = {"path": "$outpath", "partitionKeys": ["type"]},
format = "parquet")
```
# Zusammenfassen von Eingabedateien in größeren Gruppen beim Lesen
Sie können die Eigenschaften Ihrer Tabellen festlegen, damit ein AWS Glue-ETL-Auftrag Dateien gruppieren kann, wenn sie aus einem Amazon-S3-Datenspeicher gelesen werden. Diese Eigenschaften ermöglichen den einzelnen ETL-Aufträgen eine Gruppe von Eingabedateien in eine einzelne In-Memory-Partition zu lesen. Dies ist besonders nützlich, wenn es eine große Anzahl kleiner Dateien in Ihrem Amazon-S3-Datenspeicher gibt. Wenn Sie bestimmte Eigenschaften festlegen, weisen Sie AWS Glue an, Dateien innerhalb einer Amazon-S3-Datenpartition zu gruppieren und die Größe der zu lesenden Gruppen zu bestimmen. Sie können diese Optionen auch festlegen, wenn Sie mit der `create_dynamic_frame.from_options`-Methode Daten aus dem Amazon-S3-Datenspeicher lesen.
Zum Aktivieren von Gruppierungsdateien für eine Tabelle legen Sie Schlüssel-Wert-Paare im Parameterfeld Ihrer Tabellenstruktur fest. Verwenden Sie eine JSON-Notation, um einen Wert für das Parameterfeld Ihrer Tabelle festzulegen. Weitere Informationen zum Bearbeiten der Eigenschaften einer Tabelle finden Sie unter [Anzeigen und Verwalten von Tabellendetails](tables-described.md#console-tables-details).
Sie können mit dieser Methode das Gruppieren von Tabellen im Data Catalog bei Amazon-S3-Datenspeichern aktivieren.
**groupFiles**
Setzen Sie **groupFiles** auf `inPartition`, damit die Gruppierung von Dateien innerhalb einer Amazon-S3-Datenpartition ermöglicht wird. Bei mehr als 50 000 Eingabedateien aktiviert AWS Glue automatisch die Gruppierung.
```
'groupFiles': 'inPartition'
```
**groupSize**
Legen Sie **groupSize** auf die Zielgröße von Gruppen in Bytes fest. Die **groupSize**-Eigenschaft ist optional. Ist sie nicht bereitgestellt, berechnet AWS Glue eine Größe für die Verwendung aller CPU-Kerne im Cluster und reduziert gleichzeitig die Gesamtzahl an ETL-Aufträgen und In-Memory-Partitionen.
Im Folgenden wird beispielsweise die Gruppengröße auf 1 MB festgelegt.
```
'groupSize': '1048576'
```
Beachten Sie, dass `groupsize` mit dem Ergebnis einer Berechnung eingestellt werden sollte. Beispiel: 1024 \$1 1024 = 1048576.
**recurse**
Legen Sie **recurse (rekursiv)** auf `True` fest, um Dateien in allen Unterverzeichnissen zu lesen, wenn `paths` als ein Array von Pfaden angegeben wird. Sie müssen **rekursiv** nicht festlegen, wenn es sich bei `paths` um ein Array von Objektschlüsseln in Amazon S3 handelt, oder das Eingabeformat parquet/orc ist, wie im folgenden Beispiel.
```
'recurse':True
```
Wenn Sie direkt aus Amazon S3 mit der `create_dynamic_frame.from_options`-Methode lesen, fügen Sie diese Verbindungsoptionen hinzu. Im Folgenden wird beispielsweise versucht, Dateien in Gruppen mit einer Größe von 1 MB zusammenzufassen.
```
df = glueContext.create_dynamic_frame.from_options("s3", {'paths': ["s3://s3path/"], 'recurse':True, 'groupFiles': 'inPartition', 'groupSize': '1048576'}, format="json")
```
**Anmerkung**
`groupFiles`wird für die DynamicFrames Erstellung aus den folgenden Datenformaten unterstützt: csv, ion, GrokLog, json und xml. Diese Option wird für Avro, Parquet und Orc nicht unterstützt.
# Amazon-VPC-Endpunkte für Amazon S3
Aus Sicherheitsgründen führen viele AWS Kunden ihre Anwendungen in einer Amazon Virtual Private Cloud Cloud-Umgebung (Amazon VPC) aus. Mit Amazon VPC können Sie EC2 Amazon-Instances in einer virtuellen privaten Cloud starten, die logisch von anderen Netzwerken — einschließlich dem öffentlichen Internet — isoliert ist. Mit einer Amazon VPC können Sie den zugehörigen IP-Adressbereich, die Subnetze, Routing-Tabellen, Netzwerk-Gateways und Sicherheitseinstellungen steuern.
**Anmerkung**
Wenn Sie Ihr AWS Konto nach dem 04.12.2013 erstellt haben, haben Sie in jeder Region bereits eine Standard-VPC. AWS Sie können sofort beginnen, Ihre Standard-VPC zu verwenden, eine zusätzliche Konfiguration ist nicht erforderlich.
Weitere Informationen finden Sie unter [Ihre Standard-VPC und -Subnetze](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) im Amazon-VPC-Benutzerhandbuch.
Viele Kunden haben legitime Bedenken hinsichtlich Datenschutz und Sicherheit, was das Senden und Empfangen von Daten über das öffentliche Internet angeht. Kunden können dieses Problem durch die Verwendung eines Virtual Private Network (VPN) lösen, um sämtlichen Amazon-S3-Netzwerkdatenverkehr über die eigene Unternehmensnetzwerkinfrastruktur zu leiten. Dieser Ansatz kann jedoch zu Herausforderungen hinsichtlich Bandbreite und Verfügbarkeit führen.
VPC-Endpunkte für Amazon S3 können diese Herausforderungen bewältigen helfen. Ein VPC-Endpunkt für Amazon S3 ermöglicht AWS Glue die Verwendung privater IP-Adressen für den Zugriff auf Amazon S3, sodass sie nicht im öffentlichen Internet sichtbar sind. AWS Glue benötigt keine öffentlichen IP-Adressen, und Sie benötigen kein Internet-Gateway, kein NAT-Gerät oder ein Virtual Private Gateway in Ihrem VPC. Sie steuern den Zugriff auf Amazon S3 mittels Endpunktrichtlinien. Der Verkehr zwischen Ihrer VPC und dem AWS Service verlässt das Amazon-Netzwerk nicht.
Wenn Sie einen VPC-Endpunkt für Amazon S3 erstellen, werden alle Anfragen für einen Amazon-S3-Endpunkt in der Region (z. B. *s3.us-west-2.amazonaws.com*) an einen privaten Amazon-S3-Endpunkt innerhalb des Amazon-Netzwerks geleitet. Sie müssen Ihre Anwendungen, die auf EC2 Amazon-Instances in Ihrer VPC ausgeführt werden, nicht ändern — der Endpunktname bleibt derselbe, aber die Route zu Amazon S3 bleibt vollständig innerhalb des Amazon-Netzwerks und greift nicht auf das öffentliche Internet zu.
Weitere Informationen zu VPC-Endpunkten finden Sie unter [VPC-Endpunkte](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) im Amazon-VPC-Benutzerhandbuch.
Das folgende Diagramm zeigt, wie AWS Glue einen VPC-Endpunkt verwenden kann, um auf Amazon S3 zuzugreifen.
![\[Netzwerk-Datenverkehrsfluss zeigt VPC-Verbindung mit Amazon S3.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/PopulateCatalog-vpc-endpoint.png)
**So richten Sie den Zugriff für Amazon S3 ein**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie im linken Navigationsbereich die Option **Endpoints** (Endpunkte) aus.
1. Wählen Sie **Create Endpoint (Endpunkt erstellen)** aus und befolgen Sie die Schritte zum Erstellen eines Amazon-S3-VPC-Endpunkts vom Typ Gateway.
# Amazon-DocumentDB-Verbindungen
Sie können AWS Glue for Spark verwenden, um aus Tabellen in Amazon DocumentDB zu lesen und in Tabellen zu schreiben. Sie können eine Verbindung zu Amazon DocumentDB herstellen, indem Sie Anmeldeinformationen verwenden, AWS Secrets Manager die über eine AWS Glue-Verbindung gespeichert sind.
Weitere Informationen zu Amazon DocumentDB finden Sie in der [Dokumentation zu Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/what-is.html).
**Anmerkung**
Elastische Amazon DocumentDB-Cluster werden derzeit nicht unterstützt, wenn der AWS Glue-Connector verwendet wird. Weitere Informationen zu elastischen Clustern finden Sie unter [Verwendung von elastischen Amazon-DocumentDB-Clustern](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-using-elastic-clusters.html).
## Lesen und Schreiben in Amazon DocumentDB-Sammlungen
**Anmerkung**
Wenn Sie einen ETL-Auftrag erstellen, der eine Verbindung mit Amazon DocumentDB herstellt, müssen Sie für die `Connections`-Auftragseigenschaft ein Verbindungsobjekt festlegen, das die Virtual Private Cloud (VPC) angibt, in der Amazon DocumentDB ausgeführt wird. Beim Verbindungsobjekt muss der Verbindungstyp „`JDBC`“ und `JDBC URL` muss „`mongo://:27017`“ sein.
**Anmerkung**
Diese Codebeispiele wurden für AWS Glue 3.0 entwickelt. Informationen zur Migration auf AWS Glue 4.0 finden Sie unter[MongoDB](migrating-version-40.md#migrating-version-40-connector-driver-migration-mongodb). Der `uri`-Parameter hat sich geändert.
**Anmerkung**
Wenn Sie Amazon DocumentDB verwenden, muss `retryWrites` in bestimmten Situationen auf „false“ gesetzt werden, z. B. wenn das geschriebene Dokument `_id` angibt. Weitere Informationen finden Sie unter [Funktionsunterschiede zu MongoDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/functional-differences.html#functional-differences.retryable-writes) in der Dokumentation zu Amazon DocumentDB.
Das folgende Python-Skript veranschaulicht die Verwendung von Verbindungstypen und Verbindungsoptionen zum Lesen und Schreiben in Amazon DocumentDB.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
output_path = "s3://some_bucket/output/" + str(time.time()) + "/"
documentdb_uri = "mongodb://:27017"
documentdb_write_uri = "mongodb://:27017"
read_docdb_options = {
"uri": documentdb_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "1234567890",
"ssl": "true",
"ssl.domain_match": "false",
"partitioner": "MongoSamplePartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id"
}
write_documentdb_options = {
"retryWrites": "false",
"uri": documentdb_write_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "pwd"
}
# Get DynamicFrame from DocumentDB
dynamic_frame2 = glueContext.create_dynamic_frame.from_options(connection_type="documentdb",
connection_options=read_docdb_options)
# Write DynamicFrame to MongoDB and DocumentDB
glueContext.write_dynamic_frame.from_options(dynamic_frame2, connection_type="documentdb",
connection_options=write_documentdb_options)
job.commit()
```
Das folgende Scala-Skript veranschaulicht die Verwendung von Verbindungstypen und Verbindungsoptionen zum Lesen und Schreiben in Amazon DocumentDB.
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val DOC_URI: String = "mongodb://:27017"
val DOC_WRITE_URI: String = "mongodb://:27017"
lazy val documentDBJsonOption = jsonOptions(DOC_URI)
lazy val writeDocumentDBJsonOption = jsonOptions(DOC_WRITE_URI)
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Get DynamicFrame from DocumentDB
val resultFrame2: DynamicFrame = glueContext.getSource("documentdb", documentDBJsonOption).getDynamicFrame()
// Write DynamicFrame to DocumentDB
glueContext.getSink("documentdb", writeJsonOption).writeDynamicFrame(resultFrame2)
Job.commit()
}
private def jsonOptions(uri: String): JsonOptions = {
new JsonOptions(
s"""{"uri": "${uri}",
|"database":"test",
|"collection":"coll",
|"username": "username",
|"password": "pwd",
|"ssl":"true",
|"ssl.domain_match":"false",
|"partitioner": "MongoSamplePartitioner",
|"partitionerOptions.partitionSizeMB": "10",
|"partitionerOptions.partitionKey": "_id"}""".stripMargin)
}
}
```
## Referenz zur Amazon-DocumentDB-Verbindungsoption
Bezeichnet eine Verbindung zu Amazon DocumentDB (mit MongoDB-Kompatibilität).
Die Anschlussmöglichkeiten bei einer Quellverbindung und eine Senkenverbindung unterscheiden sich.
### „connectionType“: „documentdb“ als Quelle
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "documentdb"` als Quelle:
+ `"uri"`: (Erforderlich) Der als `mongodb://:` zu formatierende Amazon-DocumentDB-Host, aus dem gelesen werden soll.
+ `"database"`: (Erforderlich) Die Amazon-DocumentDB-Datenbank, aus der gelesen werden soll.
+ `"collection"`: (Erforderlich) Die Amazon-DocumentDB-Sammlung, aus der gelesen werden soll.
+ `"username"`: (Erforderlich) Der Amazon-DocumentDB-Benutzername.
+ `"password"`: (Erforderlich) Das Amazon-DocumentDB-Passwort.
+ `"ssl"`: (Erforderlich bei Verwendung von SSL) Wenn Ihre Verbindung SSL verwendet, müssen Sie diese Option mit dem Wert `"true"` einfügen.
+ `"ssl.domain_match"`: (Erforderlich bei Verwendung von SSL) Wenn Ihre Verbindung SSL verwendet, müssen Sie diese Option mit dem Wert `"false"` einfügen.
+ `"batchSize"`: (Optional): Die Anzahl der pro Batch zurückzugebenden Dokumente, die innerhalb des Cursors interner Batches verwendet werden.
+ `"partitioner"`: (Optional): Der Klassenname des Partitionierers zum Lesen von Eingabedaten aus Amazon DocumentDB. Der Konnektor stellt die folgenden Partitionierer bereit:
+ `MongoDefaultPartitioner`(Standard) (In AWS Glue 4.0 nicht unterstützt)
+ `MongoSamplePartitioner`(In AWS Glue 4.0 nicht unterstützt)
+ `MongoShardedPartitioner`
+ `MongoSplitVectorPartitioner`
+ `MongoPaginateByCountPartitioner`
+ `MongoPaginateBySizePartitioner`(In AWS Glue 4.0 nicht unterstützt)
+ `"partitionerOptions"` (Optional): Optionen für den angegebenen Partitionierer. Die folgenden Optionen werden für jeden Partitionierer unterstützt:
+ `MongoSamplePartitioner`: `partitionKey`, `partitionSizeMB`, `samplesPerPartition`
+ `MongoShardedPartitioner`: `shardkey`
+ `MongoSplitVectorPartitioner`: `partitionKey`, partitionSizeMB
+ `MongoPaginateByCountPartitioner`: `partitionKey`, `numberOfPartitions`
+ `MongoPaginateBySizePartitioner`: `partitionKey`, partitionSizeMB
Weitere Informationen zu diesen Optionen finden Sie unter [Partitioner-Konfiguration](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) in der MongoDB-Dokumentation.
### „connectionType“: „documentdb“ als Senke
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "documentdb"` als Senke:
+ `"uri"`: (Erforderlich) Der als `mongodb://:` zu formatierende Amazon-DocumentDB-Host, in den geschrieben werden soll.
+ `"database"`: (Erforderlich) Die Amazon-DocumentDB-Datenbank, in die geschrieben werden soll.
+ `"collection"`: (Erforderlich) Die Amazon-DocumentDB-Sammlung, in die geschrieben werden soll.
+ `"username"`: (Erforderlich) Der Amazon-DocumentDB-Benutzername.
+ `"password"`: (Erforderlich) Das Amazon-DocumentDB-Passwort.
+ `"extendedBsonTypes"`: (Optional) Wenn `true`, sind erweiterte BSON-Typen beim Schreiben von Daten in Amazon DocumentDB erlaubt. Der Standardwert ist `true`.
+ `"replaceDocument"`: (Optional) Wenn `true`, wird das gesamte Dokument beim Speichern von Datasets, die ein `_id`-Feld enthalten, ersetzt. Wenn `false`, werden nur Felder im Dokument aktualisiert, die mit den Feldern im Dataset übereinstimmen. Der Standardwert ist `true`.
+ `"maxBatchSize"`: (Optional): Die maximale Batchgröße für Massenvorgänge bei der Datenspeicherung. Der Standardwert ist 512.
+ `"retryWrites"`: (Optional): Automatische Wiederholung bestimmter Schreibvorgänge ein einziges Mal, wenn AWS Glue auf einen Netzwerkfehler stößt.
# OpenSearch Serviceanschlüsse
Sie können AWS Glue for Spark verwenden, um in OpenSearch Service in AWS Glue 4.0 und späteren Versionen aus Tabellen zu lesen und in Tabellen zu schreiben. Sie können mit einer OpenSearch Abfrage definieren, was aus OpenSearch Service gelesen werden soll. Sie stellen eine Verbindung mit dem OpenSearch Dienst her, indem Sie die Anmeldeinformationen für die HTTP-Standardauthentifizierung verwenden, AWS Secrets Manager die über eine AWS Glue-Verbindung gespeichert sind. Diese Funktion ist nicht mit OpenSearch Service Serverless kompatibel.
Weitere Informationen zu Amazon OpenSearch Service finden Sie in der [Amazon OpenSearch Service-Dokumentation](https://docs.aws.amazon.com/opensearch-service/).
## Konfiguration von OpenSearch Service-Verbindungen
Um von AWS Glue aus eine Verbindung zu OpenSearch Service herzustellen, müssen Sie Ihre OpenSearch Service-Anmeldeinformationen in einem AWS Secrets Manager Secret erstellen und speichern und dieses Secret dann mit einer OpenSearch Service AWS Glue-Verbindung verknüpfen.
**Voraussetzungen:**
+ Identifizieren Sie den Domain-Endpunkt *aosEndpoint* und den Port, von dem *aosPort* Sie lesen möchten, oder erstellen Sie die Ressource, indem Sie den Anweisungen in der Amazon OpenSearch Service-Dokumentation folgen. Weitere Informationen zum Erstellen einer Domain finden Sie unter [Amazon OpenSearch Service-Domains erstellen und verwalten](https://docs.aws.amazon.com//opensearch-service/latest/developerguide/createupdatedomains.html) in der Amazon OpenSearch Service-Dokumentation.
Ein Amazon OpenSearch Service-Domain-Endpunkt hat das folgende Standardformat: https://search - *domainName* -*unstructuredIdContent*. *region*.es.amazonaws.com. Weitere Informationen zur Identifizierung Ihres Domain-Endpunkts finden Sie unter [Amazon OpenSearch Service-Domains erstellen und verwalten](https://docs.aws.amazon.com//opensearch-service/latest/developerguide/createupdatedomains.html) in der Amazon OpenSearch Service-Dokumentation.
Identifizieren oder generieren Sie Anmeldeinformationen für die HTTP-Basisauthentifizierung *aosUser* und *aosPassword* für Ihre Domain.
**Um eine Verbindung zum OpenSearch Service zu konfigurieren:**
1. Erstellen Sie AWS Secrets Manager unter Verwendung Ihrer OpenSearch Dienstanmeldedaten ein Geheimnis. Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial, das in der AWS Secrets Manager Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) verfügbar ist. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `USERNAME` mit dem Wert. *aosUser*
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `PASSWORD` mit dem Wert. *aosPassword*
1. Stellen Sie in der AWS Glue-Konsole eine Verbindung her, indem Sie den Schritten unter folgen[AWS Glue Verbindung hinzufügen](console-connections.md). Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für die future Verwendung in AWS Glue bei. *connectionName*
+ Wählen Sie bei der Auswahl eines **Verbindungstyps** OpenSearch Service aus.
+ Geben Sie bei der Auswahl eines Domänenendpunkts Folgendes an*aosEndpoint*.
+ Geben Sie bei der Auswahl eines Ports an*aosPort*.
+ Geben Sie bei der Auswahl eines **AWS Secrets** Folgendes an*secretName*.
Nachdem Sie eine AWS OpenSearch Glue-Service-Verbindung hergestellt haben, müssen Sie die folgenden Schritte ausführen, bevor Sie Ihren AWS Glue-Job ausführen:
+ Erteilen Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle *secretName* Leserechte.
+ Stellen *connectionName* Sie in Ihrer AWS Glue-Job-Konfiguration eine **zusätzliche Netzwerkverbindung** bereit.
## Aus OpenSearch Dienstindizes lesen
**Voraussetzungen:**
+ Ein OpenSearch Serviceindex, aus dem Sie lesen möchten,*aosIndex*.
+ Eine AWS Glue OpenSearch Service-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkstandortinformationen bereitstellt. Um dies zu erhalten, führen Sie die Schritte im vorherigen Verfahren, *So konfigurieren Sie eine Verbindung zum OpenSearch Service*, durch. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
In diesem Beispiel wird ein Index von Amazon OpenSearch Service gelesen. Sie müssen den Parameter `pushdown` angeben.
Beispiel:
```
opensearch_read = glueContext.create_dynamic_frame.from_options(
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
"pushdown": "true",
}
)
```
Sie können auch eine Abfragezeichenfolge angeben, um die in Ihrem zurückgegebenen Ergebnisse zu filtern DynamicFrame. Sie müssen `opensearch.query` konfigurieren.
`opensearch.query`kann eine URL-Abfrageparameterzeichenfolge *queryString* oder ein DSL-JSON-Abfrageobjekt *queryObject* verwenden. Weitere Informationen zur DSL-Abfrage finden Sie in der Dokumentation unter [Query-DSL](https://opensearch.org/docs/latest/query-dsl/index/). OpenSearch Um eine URL-Abfrageparameterzeichenfolge bereitzustellen, stellen Sie `?q=` Ihrer Abfrage wie bei einer vollqualifizierten URL voran. Um ein DSL-Abfrageobjekt bereitzustellen, versehen Sie das JSON-Objekt in Escape-Zeichen, bevor Sie es bereitstellen.
Beispiel:
```
queryObject = "{ "query": { "multi_match": { "query": "Sample", "fields": [ "sample" ] } } }"
queryString = "?q=queryString"
opensearch_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
"opensearch.query": queryString,
"pushdown": "true",
}
)
```
Weitere Informationen zum Erstellen einer Abfrage außerhalb ihrer spezifischen Syntax finden Sie in der Dokumentation unter Syntax von [Abfragezeichenfolgen](https://opensearch.org/docs/latest/query-dsl/full-text/query-string/#query-string-syntax). OpenSearch
Wenn Sie aus OpenSearch Sammlungen lesen, die Daten vom Typ Array enthalten, müssen Sie in Ihrem Methodenaufruf mithilfe des `opensearch.read.field.as.array.include` Parameters angeben, welche Felder vom Typ Array sind.
Wenn Sie beispielsweise das folgende Dokument lesen, stoßen Sie auf die Array-Felder `genre` und `actor`:
```
{
"_index": "movies",
"_id": "2",
"_version": 1,
"_seq_no": 0,
"_primary_term": 1,
"found": true,
"_source": {
"director": "Frankenheimer, John",
"genre": [
"Drama",
"Mystery",
"Thriller",
"Crime"
],
"year": 1962,
"actor": [
"Lansbury, Angela",
"Sinatra, Frank",
"Leigh, Janet",
"Harvey, Laurence",
"Silva, Henry",
"Frees, Paul",
"Gregory, James",
"Bissell, Whit",
"McGiver, John",
"Parrish, Leslie",
"Edwards, James",
"Flowers, Bess",
"Dhiegh, Khigh",
"Payne, Julie",
"Kleeb, Helen",
"Gray, Joe",
"Nalder, Reggie",
"Stevens, Bert",
"Masters, Michael",
"Lowell, Tom"
],
"title": "The Manchurian Candidate"
}
}
```
In diesem Fall würden Sie diese Feldnamen in den Methodenaufruf aufnehmen. Beispiel:
```
"opensearch.read.field.as.array.include": "genre,actor"
```
Wenn ein Array-Feld innerhalb der Dokumentstruktur verschachtelt ist, verweisen Sie darauf in Punktnotation: `"genre,actor,foo.bar.baz"`. Damit geben Sie das Array `baz` in Ihrem Quelldokument an, und zwar über das eingebettete Dokument `foo`, das das eingebettete Dokument `bar` enthält.
## In OpenSearch Service-Tabellen schreiben
In diesem Beispiel werden Informationen aus einem vorhandenen DynamicFrame OpenSearch Dienst *dynamicFrame* in einen Dienst geschrieben. Wenn der Index bereits Informationen enthält, hängt AWS Glue Daten von Ihrem DynamicFrame an. Sie müssen den Parameter `pushdown` angeben.
**Voraussetzungen:**
+ Eine OpenSearch Service-Tabelle, in die Sie schreiben möchten. Sie benötigen Identifikationsinformationen für die Tabelle. Nennen wir das*tableName*.
+ Eine AWS Glue OpenSearch Service-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkstandortinformationen bereitstellt. Um dies zu erhalten, führen Sie die Schritte im vorherigen Verfahren, *So konfigurieren Sie eine Verbindung zum OpenSearch Service*, durch. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
},
)
```
## OpenSearch Referenz zur Dienstverbindungsoption
+ `connectionName` – Erforderlich. Wird für Lesen/Schreiben verwendet. Der Name einer AWS Glue OpenSearch Service-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkstandortinformationen für Ihre Verbindungsmethode bereitstellt.
+ `opensearch.resource` – Erforderlich. Wird für Lesen/Schreiben verwendet. Gültige Werte: OpenSearch Indexnamen. Der Indexname, mit dem Ihre Verbindungsmethode interagieren wird.
+ `opensearch.query` – Wird zum Lesen verwendet. Gültige Werte: JSON, in der eine Zeichenfolge in Escape-Zeichen stehen, oder, wenn diese Zeichenfolge mit `?` beginnt, der Suchteil einer URL. Eine OpenSearch Abfrage, die filtert, was beim Lesen abgerufen werden soll. Weitere Informationen zur Verwendung dieses Parameters finden Sie im vorherigen Abschnitt [Aus OpenSearch Dienstindizes lesen](#aws-glue-programming-etl-connect-opensearch-read).
+ `pushdown` – erforderlich. Zum Lesen verwendet. Zulässige Werte: Boolesch. Weist Spark an, Leseabfragen OpenSearch so weiterzuleiten, dass die Datenbank nur relevante Dokumente zurückgibt.
+ `opensearch.read.field.as.array.include` – Erforderlich, wenn Daten vom Typ Array gelesen werden. Zum Lesen verwendet. Gültige Werte: durch Kommas getrennte Listen von Feldnamen. Gibt Felder an, die als Arrays aus OpenSearch Dokumenten gelesen werden sollen. Weitere Informationen zur Verwendung dieses Parameters finden Sie im vorherigen Abschnitt [Aus OpenSearch Dienstindizes lesen](#aws-glue-programming-etl-connect-opensearch-read).
# Redshift-Verbindungen
Sie können AWS Glue for Spark verwenden, um aus Tabellen in Amazon Redshift Redshift-Datenbanken zu lesen und in Tabellen zu schreiben. Bei der Verbindung zu Amazon Redshift-Datenbanken verschiebt AWS Glue Daten mithilfe von Amazon Redshift SQL `COPY` und `UNLOAD` Befehlen über Amazon S3, um einen maximalen Durchsatz zu erzielen. In AWS Glue 4.0 und höher können Sie die [Amazon Redshift Redshift-Integration für Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) verwenden, um mit Amazon Redshift Redshift-spezifischen Optimierungen und Funktionen zu lesen und zu schreiben, die über diejenigen hinausgehen, die bei Verbindungen über frühere Versionen verfügbar sind.
Erfahren Sie, wie AWS Glue es für Amazon Redshift Redshift-Benutzer einfacher denn je macht, für serverlose Datenintegration und ETL zu AWS Glue zu migrieren.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/ZapycBq8TKU)
## Konfigurieren von Redshift-Verbindungen
Um Amazon Redshift Redshift-Cluster in AWS Glue verwenden zu können, benötigen Sie einige Voraussetzungen:
+ Ein Amazon-S3-Verzeichnis zur temporären Speicherung beim Lesen und Schreiben in die Datenbank.
+ Eine Amazon VPC, die die Kommunikation zwischen Ihrem Amazon Redshift Redshift-Cluster, Ihrem AWS Glue-Job und Ihrem Amazon S3 S3-Verzeichnis ermöglicht.
+ Entsprechende IAM-Berechtigungen für den AWS Glue-Job und den Amazon Redshift Redshift-Cluster.
### Konfiguration von IAM-Rollen
**Einrichten der Rolle für den Amazon-Redshift-Cluster**
Ihr Amazon Redshift Redshift-Cluster muss in der Lage sein, in Amazon S3 zu lesen und in Amazon S3 zu schreiben, um in AWS Glue-Jobs integriert zu werden. Um dies zu ermöglichen, können Sie IAM-Rollen dem Amazon-Redshift-Cluster zuordnen, mit dem Sie eine Verbindung herstellen möchten. Ihre Rolle sollte über eine Richtlinie verfügen, die das Lesen und Schreiben in Ihrem temporären Amazon-S3-Verzeichnis ermöglicht. Ihre Rolle sollte über eine Vertrauensbeziehung verfügen, die den `redshift.amazonaws.com`-Service zu `AssumeRole` ermöglicht.
**So ordnen Sie Amazon Redshift eine IAM-Rolle zu**
1. **Voraussetzungen:** Ein Amazon-S3-Bucket oder -Verzeichnis, der für die temporäre Speicherung von Dateien verwendet wird.
1. Identifizieren Sie, welche Amazon-S3-Berechtigungen Ihr Amazon-Redshift-Cluster benötigt. Beim Verschieben von Daten zu und von einem Amazon Redshift-Cluster geben AWS Glue-Jobs COPY- und UNLOAD-Anweisungen gegen Amazon Redshift aus. Wenn Ihr Job eine Tabelle in Amazon Redshift ändert, gibt AWS Glue auch CREATE LIBRARY-Anweisungen aus. Informationen zu bestimmten Amazon S3 S3-Berechtigungen, die Amazon Redshift zur Ausführung dieser Anweisungen benötigt, finden Sie in der Amazon Redshift-Dokumentation: [Amazon Redshift: Zugriffsberechtigungen für andere Ressourcen](https://docs.aws.amazon.com/redshift/latest/dg/copy-usage_notes-access-permissions.html). AWS
1. Erstellen Sie in der IAM-Konsole eine IAM-Richtlinie mit den erforderlichen Berechtigungen. Weitere Informationen zum Erstellen einer Richtlinie finden Sie unter [Erstellen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
1. Erstellen Sie in der IAM-Konsole eine Rolle und eine Vertrauensbeziehung, die es Amazon Redshift ermöglicht, die Rolle zu übernehmen. Folgen Sie den Anweisungen in der IAM-Dokumentation, [um eine Rolle für einen AWS Service (Konsole) zu erstellen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console)
+ Wenn Sie aufgefordert werden, einen AWS Service-Anwendungsfall auszuwählen, wählen Sie „Redshift — Customizable“.
+ Wenn Sie aufgefordert werden, eine Richtlinie anzufügen, wählen Sie die zuvor definierte Richtlinie aus.
**Anmerkung**
Weitere Informationen zur Konfiguration von Rollen für Amazon Redshift finden Sie in der [Amazon Redshift-Dokumentation unter Autorisieren von Amazon Redshift, in Ihrem Namen auf andere AWS Services zuzugreifen](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html).
1. Ordnen Sie in der Amazon-Redshift-Konsole die Rolle Ihrem Amazon-Redshift-Cluster zu. Folgen Sie den Anweisungen in der [Amazon-Redshift-Dokumentation](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html).
Wählen Sie die hervorgehobene Option in der Amazon-Redshift-Konsole aus, um diese Einstellung zu konfigurieren:
![\[Ein Beispiel dafür, wo IAM-Berechtigungen in der Amazon-Redshift-Konsole verwaltet werden.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/RS-role-config.png)
**Anmerkung**
Standardmäßig übergeben AWS Glue-Jobs temporäre Amazon Redshift Redshift-Anmeldeinformationen, die mit der Rolle erstellt wurden, die Sie für die Ausführung des Jobs angegeben haben. Wir raten von der Verwendung dieser Anmeldeinformationen ab. Aus Sicherheitsgründen verfallen diese Zugangsdaten nach einer Stunde.
**Richten Sie die Rolle für den AWS Glue-Job ein**
Der AWS Glue-Job benötigt eine Rolle für den Zugriff auf den Amazon S3 S3-Bucket. Sie benötigen keine IAM-Berechtigungen für den Amazon-Redshift-Cluster. Ihr Zugriff wird durch die Konnektivität in Amazon VPC und Ihre Datenbankanmeldeinformationen gesteuert.
### Einrichten der Amazon VPC
**So richten Sie den Zugriff für Amazon-Redshift-Datenspeicher ein**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon Redshift Redshift-Konsole unter [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/).
1. Wählen Sie im linken Navigationsbereich **Cluster** aus.
1. Wählen Sie den Cluster-Namen aus, auf den Sie von AWS Glue zugreifen möchten.
1. Wählen Sie im Abschnitt **Cluster Properties** (Cluster-Eigenschaften) eine Sicherheitsgruppe in **VPC-Sicherheitsgruppen** aus, die AWS Glue verwenden darf. Notieren Sie sich den Namen der Sicherheitsgruppe, die Sie gewählt haben, um später darauf zurückgreifen zu können. Wenn Sie die Sicherheitsgruppe auswählen, wird die **Sicherheitsgruppen**-Liste der Amazon-EC2-Konsole geöffnet.
1. Wählen Sie die Sicherheitsgruppe aus, die geändert werden soll, und navigieren Sie zur Registerkarte **Eingehend**.
1. Fügen Sie eine selbstreferenzierende Regel hinzu, um die Kommunikation von AWS Glue-Komponenten zuzulassen. Insbesondere fügen Sie hinzu oder bestätigen Sie, dass eine Regel des **Typs** `All TCP` vorhanden ist, das **Protokoll** `TCP` lautet, der **Port-Bereich** alle Ports umfasst und deren **Quelle** über denselben Sicherheitsgruppennamen verfügt wie die **Gruppen-ID**.
Die eingehende Regel sollte wie folgt aussehen:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
Beispiel:
![\[Ein Beispiel für eine selbstreferenzierende eingehende Regel.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/SetupSecurityGroup-Start.png)
1. Fügen Sie ebenfalls eine Regel für ausgehenden Datenverkehr hinzu. Erlauben Sie entweder ausgehenden Datenverkehr für alle Ports, beispielsweise:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
Oder erstellen Sie eine selbstreferenzierende Regel, wobei der **Typ** `All TCP` ist, das **Protokoll** `TCP` lautet, der **Port-Bereich** alle Ports umfasst und deren **Ziel** über denselben Sicherheitsgruppennamen wie die **Gruppen-ID** verfügt. Wenn Sie einen Amazon-S3-VPC-Endpunkt verwenden, fügen Sie auch eine HTTPS-Regel für den Amazon-S3-Zugriff hinzu. Das *s3-prefix-list-id* ist in der Sicherheitsgruppenregel erforderlich, um Datenverkehr von der VPC zum Amazon S3 S3-VPC-Endpunkt zuzulassen.
Beispiel:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
### AWS Glue einrichten
Sie müssen eine AWS Glue Data Catalog-Verbindung erstellen, die Amazon VPC-Verbindungsinformationen bereitstellt.
**So konfigurieren Sie die Amazon Redshift Amazon VPC-Konnektivität zu AWS Glue in der Konsole**
1. Erstellen Sie eine Data-Catalog-Verbindung, indem Sie die Schritte in [AWS Glue Verbindung hinzufügen](console-connections.md) ausführen. Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für den nächsten Schritt bei. *connectionName*
+ Wählen Sie bei der Auswahl eines **Verbindungstyps** die Option **Amazon Redshift** aus.
+ Wählen Sie bei der Auswahl eines **Redshift-Clusters** Ihren Cluster nach Namen aus.
+ Stellen Sie Standardverbindungsinformationen für einen Amazon-Redshift-Benutzer in Ihrem Cluster bereit.
+ Ihre Amazon-VPC-Einstellungen werden automatisch konfiguriert.
**Anmerkung**
Sie müssen `PhysicalConnectionRequirements` manuell für Ihre Amazon VPC bereitstellen, wenn Sie eine **Amazon Redshift**-Verbindung über das AWS SDK erstellen.
1. Stellen *connectionName* Sie in Ihrer AWS Glue-Job-Konfiguration eine **zusätzliche Netzwerkverbindung** bereit.
## Beispiel: Lesen aus Amazon-Redshift-Tabellen
Sie können aus Amazon-Redshift-Clustern und Serverless-Amazon-Redshift-Umgebungen lesen.
**Voraussetzungen:** Eine Amazon-Redshift-Tabelle, aus der Sie gerne lesen möchten. Folgen Sie den Schritten im vorherigen Abschnitt. [Konfigurieren von Redshift-Verbindungen](#aws-glue-programming-etl-connect-redshift-configure) Danach sollten Sie den Amazon S3 S3-URI für ein temporäres Verzeichnis *temp-s3-dir* und eine IAM-Rolle,*rs-role-name*, (im Konto*role-account-id*) haben.
------
#### [ Using the Data Catalog ]
**Zusätzliche Voraussetzungen:** Eine Data-Catalog-Datenbank und -Tabelle für die Amazon-Redshift-Tabelle, aus der Sie lesen möchten. Weitere Informationen zu Data Catalog finden Sie unter [Datenermittlung und Katalogisierung in AWS Glue](catalog-and-crawler.md). Nachdem Sie einen Eintrag für Ihre Amazon Redshift Redshift-Tabelle erstellt haben, identifizieren Sie Ihre Verbindung mit einem *redshift-dc-database-name* und*redshift-table-name*.
**Konfiguration:** In Ihren Funktionsoptionen identifizieren Sie Ihre Datenkatalogtabelle mit den `database`- und `table_name`-Parametern. Sie identifizieren Ihr temporäres Amazon-S3-Verzeichnis mit `redshift_tmp_dir`. Sie geben dies auch *rs-role-name* mithilfe des `aws_iam_role` Schlüssels im `additional_options` Parameter an.
```
glueContext.create_dynamic_frame.from_catalog(
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"})
```
------
#### [ Connecting directly ]
**Zusätzliche Voraussetzungen:** Sie benötigen den Namen Ihrer Amazon Redshift Redshift-Tabelle (*redshift-table-name*. Sie benötigen die JDBC-Verbindungsinformationen für den Amazon-Redshift-Cluster, der diese Tabelle speichert. Sie geben Ihre Verbindungsinformationen mit*host*, *port**redshift-database-name*, *username* und *password* an.
Sie können Ihre Verbindungsinformationen von der Amazon-Redshift-Konsole abrufen, wenn Sie mit Amazon-Redshift-Clustern arbeiten. Wenn Sie Amazon Redshift Serverless verwenden, lesen Sie den Abschnitt [Herstellen einer Verbindung zu Amazon Redshift Serverless](https://docs.aws.amazon.com//redshift/latest/mgmt/serverless-connecting.html) in der Amazon Redshift-Dokumentation.
**Konfiguration:** In Ihren Funktionsoptionen kennzeichnen Sie Ihre Verbindungsparameter `url`, `dbtable`, `user` und `password`. Sie identifizieren Ihr temporäres Amazon-S3-Verzeichnis mit `redshift_tmp_dir`. Sie können Ihre IAM-Rolle mit `aws_iam_role` angeben, wenn Sie `from_options` verwenden. Die Syntax ähnelt der Verbindung über den Datenkatalog, Sie geben die Parameter jedoch in die `connection_options`-Zuordnung ein.
Es ist eine schlechte Praxis, Passwörter in AWS Glue-Skripten fest zu codieren. Erwägen Sie, Ihre Passwörter in Ihrem Skript mit SDK for Python (Boto3) zu speichern AWS Secrets Manager und von dort abzurufen.
```
my_conn_options = {
"url": "jdbc:redshift://host:port/redshift-database-name",
"dbtable": "redshift-table-name",
"user": "username",
"password": "password",
"redshiftTmpDir": args["temp-s3-dir"],
"aws_iam_role": "arn:aws:iam::account id:role/rs-role-name"
}
df = glueContext.create_dynamic_frame.from_options("redshift", my_conn_options)
```
------
## Beispiel: Schreiben in Amazon-Redshift-Tabellen
Sie können in Amazon-Redshift-Cluster und Serverless-Amazon-Redshift-Umgebungen schreiben.
**Voraussetzungen:** Ein Amazon Redshift Redshift-Cluster und folgen Sie den Schritten im vorherigen Abschnitt. [Konfigurieren von Redshift-Verbindungen](#aws-glue-programming-etl-connect-redshift-configure) Danach sollten Sie die Amazon S3 S3-URI für ein temporäres Verzeichnis *temp-s3-dir* und eine IAM-Rolle,*rs-role-name*, (im Konto*role-account-id*) haben. Sie benötigen außerdem einen `DynamicFrame`, dessen Inhalt Sie in die Datenbank schreiben möchten.
------
#### [ Using the Data Catalog ]
**Zusätzliche Voraussetzungen** Eine Datenkatalogdatenbank für den Amazon-Redshift-Cluster und die Tabelle, in die Sie schreiben möchten. Weitere Informationen zu Data Catalog finden Sie unter [Datenermittlung und Katalogisierung in AWS Glue](catalog-and-crawler.md). Sie identifizieren Ihre Verbindung mit *redshift-dc-database-name* und die Zieltabelle mit. *redshift-table-name*
**Konfiguration:** In Ihren Funktionsoptionen identifizieren Sie Ihre Data-Catalog-Datenbank mit dem `database`-Parameter und stellen dann die Tabelle mit `table_name` bereit. Sie identifizieren Ihr temporäres Amazon-S3-Verzeichnis mit `redshift_tmp_dir`. Sie werden dies auch *rs-role-name* mithilfe des `aws_iam_role` Schlüssels im `additional_options` Parameter angeben.
```
glueContext.write_dynamic_frame.from_catalog(
frame = input dynamic frame,
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::account-id:role/rs-role-name"})
```
------
#### [ Connecting through a AWS Glue connection ]
Mit dieser `write_dynamic_frame.from_options`-Methode können Sie direkt eine Verbindung zu Amazon Redshift herstellen. Anstatt Ihre Verbindungsdetails jedoch direkt in Ihr Skript einzufügen, können Sie mit der `from_jdbc_conf`-Methode auf Verbindungsdetails verweisen, die in einer Data-Catalog-Verbindung gespeichert sind. Sie können dies tun, ohne Ihre Datenbank zu crawlen oder Data-Catalog-Tabellen zu erstellen. Weitere Informationen zu Data-Catalog-Verbindungen finden Sie unter [Herstellen einer Verbindung zu Daten](glue-connections.md).
**Zusätzliche Voraussetzungen:** Eine Data-Catalog-Verbindung für Ihre Datenbank, eine Amazon-Redshift-Tabelle, aus der Sie lesen möchten
**Konfiguration:** Sie identifizieren Ihre Datenkatalogverbindung mit*dc-connection-name*. Sie identifizieren Ihre Amazon Redshift Redshift-Datenbank und -Tabelle mit *redshift-table-name* und*redshift-database-name*. Sie geben Ihre Data Catalog-Verbindungsinformationen mit `catalog_connection` und Ihre Amazon-Redshift-Informationen mit `dbtable` und `database` an. Die Syntax ähnelt der Verbindung über den Datenkatalog, Sie geben die Parameter jedoch in die `connection_options`-Zuordnung ein.
```
my_conn_options = {
"dbtable": "redshift-table-name",
"database": "redshift-database-name",
"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"
}
glueContext.write_dynamic_frame.from_jdbc_conf(
frame = input dynamic frame,
catalog_connection = "dc-connection-name",
connection_options = my_conn_options,
redshift_tmp_dir = args["temp-s3-dir"])
```
------
## Referenz zur Amazon-Redshift-Verbindungsoption
Die grundlegenden Verbindungsoptionen, die für alle AWS Glue-JDBC-Verbindungen verwendet werden, um Informationen wie einzurichten`url`, `user` und `password` sind für alle JDBC-Typen konsistent. Weitere Informationen zu Standard-JDBC-Parametern finden Sie unter [Referenz zur JDBC-Verbindungsoption](aws-glue-programming-etl-connect-jdbc-home.md#aws-glue-programming-etl-connect-jdbc).
Der Amazon-Redshift-Verbindungstyp erfordert einige zusätzliche Verbindungsoptionen:
+ `"redshiftTmpDir"`: (Erforderlich) Der Amazon-S3-Pfad, in dem temporäre Daten beim Kopieren aus der Datenbank bereitgestellt werden können.
+ `"aws_iam_role"`: (Optional) ARN für eine IAM-Rolle. Der AWS Glue-Job leitet diese Rolle an den Amazon Redshift Redshift-Cluster weiter, um den Cluster-Berechtigungen zu erteilen, die für die Ausführung der Anweisungen aus dem Job erforderlich sind.
### Zusätzliche Verbindungsoptionen in AWS Glue 4.0\$1 verfügbar
Sie können Optionen für den neuen Amazon Redshift Redshift-Connector auch über die AWS Glue-Verbindungsoptionen übergeben. Eine vollständige Liste der unterstützten Konnektor-Optionen finden Sie im Abschnitt *Spark-SQL-Parameter* unter [Amazon-Redshift-Integration für Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html).
Zur Vereinfachung möchten wir Sie hier noch einmal auf bestimmte neue Optionen hinweisen:
| Name | Erforderlich | Standard | Description |
| --- | --- | --- | --- |
| autopushdown | Nein | TRUE | Wendet Prädikat- und Abfrage-Pushdown durch Erfassen und Analysieren der logischen Spark-Pläne für SQL-Vorgänge an. Die Operationen werden in eine SQL-Abfrage übersetzt und dann zur Verbesserung der Leistung in Amazon Redshift ausgeführt. |
| autopushdown.s3\$1result\$1cache | Nein | FALSE | Zwischenspeichert die SQL-Abfrage zum Entladen von Daten für die Amazon-S3-Pfadzuordnung im Arbeitsspeicher, sodass dieselbe Abfrage nicht erneut in derselben Spark-Sitzung ausgeführt werden muss. Wird nur unterstützt wenn `autopushdown` aktiviert ist. |
| unload\$1s3\$1format | Nein | PARQUET | PARQUET – Entlädt die Abfrageergebnisse im Parquet-Format. TEXT – Entlädt die Abfrageergebnisse im durch Pipes getrennten Textformat. |
| sse\$1kms\$1key | Nein | – | Der AWS SSE-KMS-Schlüssel, der für die Verschlüsselung während des `UNLOAD` Betriebs verwendet werden soll, anstelle der Standardverschlüsselung für. AWS |
| extracopyoptions | Nein | – | Eine Liste zusätzlicher Optionen, die beim Laden von Daten an den `COPY`-Befehl von Amazon Redshift angehängt werden, wie z. B. `TRUNCATECOLUMNS` oder `MAXERROR n` (weitere Optionen finden Sie unter [COPY: Optionale Parameter](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax-overview-optional-parameters)). Beachten Sie, dass nur Optionen verwendet werden können, die am Ende des Befehls sinnvoll sind, da diese Optionen an das Ende des `COPY`-Befehls angefügt werden. Damit sollten die meisten Anwendungsfälle abgedeckt werden. |
| csvnullstring (experimentell) | Nein | NULL | Der Zeichenfolgenwert, der für Nullen geschrieben werden soll, wenn Sie die CSV `tempformat` verwenden. Dies sollte ein Wert sein, der in Ihren tatsächlichen Daten nicht vorkommt. |
Diese neuen Parameter können auf folgende Weise verwendet werden.
**Neue Optionen zur Leistungsverbesserung**
Der neue Konnektor bietet einige neue Optionen zur Leistungsverbesserung:
+ `autopushdown`: Standardmäßig aktiviert.
+ `autopushdown.s3_result_cache`: Standardmäßig deaktiviert.
+ `unload_s3_format`: Standardmäßig `PARQUET`.
Informationen zur Verwendung dieser Optionen finden Sie unter [Amazon-Redshift-Integration für Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). Es wird empfohlen, das ` autopushdown.s3_result_cache` nicht einzuschalten, wenn Sie Lese- und Schreibvorgänge miteinander kombinieren, da die zwischengespeicherten Ergebnisse möglicherweise veraltete Informationen enthalten. Die Option `unload_s3_format` ist standardmäßig auf `PARQUET` für den `UNLOAD`-Befehl festgelegt, um die Leistung zu verbessern und die Speicherkosten zu reduzieren. Um das Standardverhalten des `UNLOAD`-Befehls zu verwenden, setzen Sie die Option auf `TEXT` zurück.
**Neue Verschlüsselungsoption für das Lesen**
Standardmäßig werden die Daten im temporären Ordner, den AWS Glue beim Lesen von Daten aus der Amazon-Redshift-Tabelle verwendet, mit der `SSE-S3`-Verschlüsselung verschlüsselt. Um Ihre Daten mit vom Kunden verwalteten Schlüsseln von AWS Key Management Service (AWS KMS) zu verschlüsseln, können Sie festlegen, dass KSMKey die [Schlüssel-ID](https://docs.aws.amazon.com/kms/latest/developerguide/find-cmk-id-arn.html) ist AWS KMS, und nicht die alte Einstellungsoption `("sse_kms_key" → kmsKey)` in Version 3.0. `("extraunloadoptions" → s"ENCRYPTED KMS_KEY_ID '$kmsKey'")` AWS Glue
```
datasource0 = glueContext.create_dynamic_frame.from_catalog(
database = "database-name",
table_name = "table-name",
redshift_tmp_dir = args["TempDir"],
additional_options = {"sse_kms_key":""},
transformation_ctx = "datasource0"
)
```
**Unterstützung von IAM-basierter JDBC-URL**
Der neue Connector unterstützt eine IAM-basierte JDBC-URL, sodass Sie keine geheime URL eingeben müssen. user/password Bei einer IAM-basierten JDBC-URL verwendet der Konnektor die Laufzeitrolle des Auftrags für den Zugriff auf die Amazon-Redshift-Datenquelle.
Schritt 1: Fügen Sie die folgende minimal erforderliche Richtlinie an Ihre AWS Glue-Auftrag-Laufzeitrolle an.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "redshift:GetClusterCredentials",
"Resource": [
"arn:aws:redshift:us-east-1:111122223333:dbgroup:/*",
"arn:aws:redshift:*:111122223333:dbuser:*/*",
"arn:aws:redshift:us-east-1:111122223333:dbname:/"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "redshift:DescribeClusters",
"Resource": "*"
}
]
}
```
------
Schritt 2: Verwenden Sie die IAM-basierte JDBC-URL wie folgt. Geben Sie eine neue Option `DbUser` mit dem Amazon-Redshift-Benutzernamen an, mit dem Sie eine Verbindung herstellen.
```
conn_options = {
// IAM-based JDBC URL
"url": "jdbc:redshift:iam://:/",
"dbtable": dbtable,
"redshiftTmpDir": redshiftTmpDir,
"aws_iam_role": aws_iam_role,
"DbUser": "" // required for IAM-based JDBC URL
}
redshift_write = glueContext.write_dynamic_frame.from_options(
frame=dyf,
connection_type="redshift",
connection_options=conn_options
)
redshift_read = glueContext.create_dynamic_frame.from_options(
connection_type="redshift",
connection_options=conn_options
)
```
**Anmerkung**
Ein `DynamicFrame` unterstützt derzeit nur eine IAM-basierte JDBC-URL mit einem ` DbUser` im `GlueContext.create_dynamic_frame.from_options`-Workflow.
## Migrieren von der AWS Glue-Version 3.0 zu Version 4.0
In AWS Glue 4.0 haben ETL-Jobs Zugriff auf einen neuen Amazon Redshift Spark-Konnektor und einen neuen JDBC-Treiber mit unterschiedlichen Optionen und Konfigurationen. Der neue Amazon-Redshift-Konnektor und -Treiber sind auf Leistung ausgelegt und gewährleisten die Transaktionskonsistenz Ihrer Daten. Diese Produkte sind in der Amazon-Redshift-Dokumentation dokumentiert. Weitere Informationen finden Sie unter:
+ [Amazon-Redshift-Integration für Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html)
+ [Amazon-Redshift-JDBC-Treiber, Version 2.1](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-download-driver.html)
**Einschränkung für Tabellen-/Spaltennamen und Kennungen**
Für den neuen Amazon-Redshift-Spark-Konnektor und -Treiber gelten strengere Anforderungen für den Redshift-Tabellennamen. Weitere Informationen finden Sie unter [Namen und Kennungen](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) zum Definieren des Namens Ihrer Amazon-Redshift-Tabelle. Der Workflow für Auftragslesezeichen funktioniert möglicherweise nicht mit einem Tabellennamen, der nicht mit den Regeln übereinstimmt, und mit bestimmten Zeichen, z. B. einem Leerzeichen.
Wenn Sie über veraltete Tabellen mit Namen verfügen, die nicht den Regeln für [Namen und Kennungen](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) entsprechen, und Probleme mit Lesezeichen sehen (Aufträge, die alte Amazon-Redshift-Tabellendaten neu verarbeiten), empfehlen wir Ihnen, Ihre Tabellennamen umzubenennen. Weitere Informationen finden Sie unter [ALTER-TABLE-Beispiele](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_TABLE_examples_basic.html).
**Änderung des Standard-Tempformats in Dataframe**
Der Spark-Konnektor der AWS Glue-Version 3.0 setzt `tempformat` beim Schreiben in Amazon Redshift standardmäßig auf CSV. Um konsistent zu sein, wird in der AWS Glue-Version 3.0 der ` DynamicFrame` immer noch standardmäßig von dem `tempformat` verwendet, um `CSV` zu verwenden. Wenn Sie Spark Dataframe zuvor APIs direkt mit dem Amazon Redshift Spark-Konnektor verwendet haben, können Sie den in den `DataframeReader` Optionen/explizit `tempformat` auf CSV setzen. `Writer` Andernfalls wird `tempformat` im neuen Spark-Konnektor standardmäßig auf `AVRO` festgelegt.
**Verhaltensänderung: Amazon-Redshift-Datentyp REAL dem Spark-Datentyp FLOAT anstelle von DOUBLE zuordnen**
In der AWS Glue-Version 3.0 wird Amazon Redshift `REAL` in einen ` DOUBLE`-Typ von Spark konvertiert. Der neue Amazon-Redshift-Spark-Konnektor hat das Verhalten so aktualisiert, dass der ` REAL`-Typ von Amazon Redshift in den `FLOAT`-Typ von Spark konvertiert wird und umgekehrt. Wenn Sie einen älteren Anwendungsfall haben, bei dem Sie den `REAL`-Typ von Amazon Redshift weiterhin einem `DOUBLE`-Typ von Spark zuordnen möchten, können Sie die folgende Problemumgehung verwenden:
+ Ordnen Sie für eine `DynamicFrame` den `Float`-Typ einem `Double`-Typ mit `DynamicFrame.ApplyMapping` zu. Für eine `Dataframe` müssen Sie `cast` verwenden.
Codebeispiel:
```
dyf_cast = dyf.apply_mapping([('a', 'long', 'a', 'long'), ('b', 'float', 'b', 'double')])
```
**Umgang mit dem VARBYTE-Datentyp**
Bei der Arbeit mit den Datentypen AWS Glue 3.0 und Amazon Redshift konvertiert AWS Glue 3.0 Amazon Redshift in `VARBYTE` den `STRING` Spark-Typ. Der aktuelle Spark-Connector von Amazon Redshift unterstützt den Datentyp `VARBYTE` jedoch nicht. Um diese Einschränkung zu umgehen, können Sie [eine Redshift-Ansicht erstellen](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_VIEW.html), die `VARBYTE`-Spalten in einen unterstützten Datentyp umwandelt. Verwenden Sie dann den neuen Connector, um Daten aus dieser Ansicht statt aus der Originaltabelle zu laden. Dadurch wird die Kompatibilität gewährleistet und gleichzeitig der Zugriff auf Ihre `VARBYTE`-Daten gewahrt.
Beispiel für eine Redshift-Abfrage:
```
CREATE VIEW view_name AS SELECT FROM_VARBYTE(varbyte_column, 'hex') FROM table_name
```
# Kafka-Verbindungen
Sie können eine Kafka-Verbindung verwenden, um in Kafka-Datenströmen zu lesen oder zu schreiben, indem Sie Informationen nutzen, die in einer Datenkatalogtabelle gespeichert sind, oder indem Sie Informationen bereitstellen, um direkt auf den Datenstrom zuzugreifen. Die Verbindung unterstützt einen Kafka-Cluster oder einem Cluster von Amazon Managed Streaming for Apache Kafka. Sie können Informationen aus Kafka in einen Spark einlesen DataFrame und sie dann in einen AWS Glue DynamicFrame umwandeln. Sie können in einem JSON-Format in Kafka schreiben DynamicFrames . Wenn Sie direkt auf den Datenstrom zugreifen, verwenden Sie diese Optionen, um Informationen zum Zugriff auf den Datenstrom bereitzustellen.
Wenn Sie `getCatalogSource` oder `create_data_frame_from_catalog` verwenden, um Datensätze aus einer Kafka-Streaming-Quelle zu verbrauchen, oder `getCatalogSink` oder `write_dynamic_frame_from_catalog`, um Datensätze in Kafka zu schreiben, enthält der Auftrag die Informationen zur Datenkatalog-Datenbank und Tabellennamen und kann diese verwenden, um einige grundlegende Parameter für das Lesen aus der Kafka-Streaming-Quelle zu erhalten. Wenn Sie `getSource`, `getCatalogSink`, `getSourceWithFormat`, `getSinkWithFormat`, `createDataFrameFromOptions` oder `create_data_frame_from_options` oder `write_dynamic_frame_from_catalog` verwenden, müssen Sie diese grundlegenden Parameter mithilfe der hier beschriebenen Verbindungsoptionen angeben.
Sie können die Verbindungsoptionen für Kafka mit den folgenden Argumenten für die angegebenen Methoden in der `GlueContext`-Klasse angeben.
+ Scala
+ `connectionOptions`: mit `getSource`, `createDataFrameFromOptions`, `getSink` verwenden
+ `additionalOptions`: mit `getCatalogSource`, `getCatalogSink` verwenden
+ `options`: mit `getSourceWithFormat`, `getSinkWithFormat` verwenden
+ Python
+ `connection_options`: mit `create_data_frame_from_options`, `write_dynamic_frame_from_options` verwenden
+ `additional_options`: mit `create_data_frame_from_catalog`, `write_dynamic_frame_from_catalog` verwenden
+ `options`: mit `getSource`, `getSink` verwenden
Hinweise und Einschränkungen zum Streaming von ETL-Aufträgen finden Sie unter [Hinweise zu und Einschränkungen für Streaming-ETL](add-job-streaming.md#create-job-streaming-restrictions).
**Topics**
+ [Kafka konfigurieren](#aws-glue-programming-etl-connect-kafka-configure)
+ [Beispiel: Aus Kafka-Streams lesen](#aws-glue-programming-etl-connect-kafka-read)
+ [Beispiel: In Kafka-Streams schreiben](#aws-glue-programming-etl-connect-kafka-write)
+ [Referenz zur Kafka-Verbindungsoption](#aws-glue-programming-etl-connect-kafka)
## Kafka konfigurieren
Es gibt keine AWS Voraussetzungen für die Verbindung zu Kafka-Streams, die über das Internet verfügbar sind.
Sie können eine AWS Glue Kafka-Verbindung erstellen, um Ihre Verbindungsdaten zu verwalten. Weitere Informationen finden Sie unter [Erstellen einer AWS Glue-Verbindung für einen Apache-Kafka-Datenstrom](add-job-streaming.md#create-conn-streaming). Geben Sie in Ihrer AWS Glue-Job-Konfiguration *connectionName* als **Zusätzliche Netzwerkverbindung** an und geben Sie dann in Ihrem Methodenaufruf den `connectionName` Parameter *connectionName* an.
In bestimmten Fällen müssen Sie zusätzliche Voraussetzungen konfigurieren:
+ Wenn Sie Amazon Managed Streaming für Apache Kafka mit IAM-Authentifizierung verwenden, benötigen Sie eine entsprechende IAM-Konfiguration.
+ Wenn Sie Amazon Managed Streaming für Apache Kafka innerhalb einer Amazon VPC verwenden, benötigen Sie eine entsprechende Amazon-VPC-Konfiguration. Sie müssen eine AWS Glue-Verbindung erstellen, die Amazon VPC-Verbindungsinformationen bereitstellt. Sie benötigen in Ihrer Jobkonfiguration die AWS Glue-Verbindung als **zusätzliche Netzwerkverbindung**.
Weitere Informationen zu den Voraussetzungen für Streaming-ETL-Aufträgen finden Sie unter [Streaming-ETL-Aufträge in AWS Glue](add-job-streaming.md).
## Beispiel: Aus Kafka-Streams lesen
Verwendet in Verbindung mit [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
Beispiel für die Kafka-Streaming-Quelle:
```
kafka_options =
{ "connectionName": "ConfluentKafka",
"topicName": "kafka-auth-topic",
"startingOffsets": "earliest",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kafka", connection_options=kafka_options)
```
## Beispiel: In Kafka-Streams schreiben
Beispiele für das Schreiben in Kafka:
Beispiel mit der `getSink`-Methode:
```
data_frame_datasource0 =
glueContext.getSink(
connectionType="kafka",
connectionOptions={
JsonOptions("""{
"connectionName": "ConfluentKafka",
"classification": "json",
"topic": "kafka-auth-topic",
"typeOfData": "kafka"}
""")},
transformationContext="dataframe_ApacheKafka_node1711729173428")
.getDataFrame()
```
Beispiel mit der `write_dynamic_frame.from_options`-Methode:
```
kafka_options =
{ "connectionName": "ConfluentKafka",
"topicName": "kafka-auth-topic",
"classification": "json"
}
data_frame_datasource0 = glueContext.write_dynamic_frame.from_options(connection_type="kafka", connection_options=kafka_options)
```
## Referenz zur Kafka-Verbindungsoption
Verwenden Sie beim Lesen die folgenden Verbindungsoptionen mit `"connectionType": "kafka"`:
+ `"bootstrap.servers"`(Erforderlich) Eine Liste von URLs Bootstrap-Servern, zum Beispiel als`b-1.vpc-test-2.o4q88o.c6.kafka.us-east-1.amazonaws.com:9094`. Diese Option muss im API-Aufruf angegeben oder in den Tabellenmetadaten im Data Catalog definiert werden.
+ `"security.protocol"` (Erforderlich) Das Protokoll, das für die Kommunikation mit Brokern verwendet wird. Die möglichen Werte sind `"SSL"` oder `"PLAINTEXT"`.
+ `"topicName"` (Erforderlich) Eine durch Kommas getrennte Liste von Themen, die abonniert werden sollen. Sie müssen nur eines der folgenden `"topicName"`, `"assign"` oder `"subscribePattern"` angeben.
+ `"assign"`: (Erforderlich) Eine JSON-Zeichenfolge, welche den spezifischen `TopicPartitions` zum Konsumieren angeben. Sie müssen nur eines der folgenden `"topicName"`, `"assign"` oder `"subscribePattern"` angeben.
Beispiel: '\$1"topicA":[0,1],"topicB":[2,4]\$1'
+ `"subscribePattern"`: (Erforderlich) Eine Java-Regex-Zeichenfolge, die die Themenliste identifiziert, die abonniert werden soll. Sie müssen nur eines der folgenden `"topicName"`, `"assign"` oder `"subscribePattern"` angeben.
Beispiel: 'topic.\$1'
+ `"classification"` (Erforderlich) Das von den Daten im Datensatz verwendete Dateiformat. Erforderlich, sofern nicht in Data Catalog angegeben.
+ `"delimiter"` (Optional) Das verwendete Werttrennzeichen, wenn `classification` CSV ist. Der Standardwert ist „`,`„.
+ `"startingOffsets"`: (Optional) Die Ausgangsposition im Kafka-Thema, aus dem Daten gelesen werden sollen. Die möglichen Werte sind `"earliest"` oder `"latest"`. Der Standardwert ist `"latest"`.
+ `"startingTimestamp"`: (Optional, nur für AWS Glue Version 4.0 oder höher unterstützt) Der Zeitstempel des Datensatzes im Kafka-Thema, aus dem Daten gelesen werden sollen. Der mögliche Wert ist eine Zeitstempelzeichenfolge im UTC-Format im Muster `yyyy-mm-ddTHH:MM:SSZ` (wobei `Z` einen UTC-Zeitzonenversatz mit einem \$1/- darstellt. Beispiel: „2023-04-04T08:00:00-04:00“).
Hinweis: In der Liste der Verbindungsoptionen des AWS Glue-Streaming-Skripts kann nur eine von 'StartingOffsets' oder 'StartingTimeStamp' vorhanden sein. Wenn Sie diese beiden Eigenschaften angeben, schlägt der Job fehl.
+ `"endingOffsets"`: (Optional) Der Endpunkt, wenn eine Batchabfrage beendet wird. Die möglichen Werte sind entweder `"latest"` oder eine JSON-Zeichenfolge, die einen Offset für das Ende jeder `TopicPartition` angibt.
Für die JSON-Zeichenfolge lautet das Format `{"topicA":{"0":23,"1":-1},"topicB":{"0":-1}}`. Der Wert `-1` als Offset steht für `"latest"`.
+ `"pollTimeoutMs"`: (Optional) Das Timeout in Millisekunden, um Daten von Kafka in Spark-Auftragsausführungen abzufragen. Der Standardwert ist `600000`.
+ `"numRetries"`: (Optional) Die Anzahl, wie oft erneute Versuche durchgeführt werden sollen, bevor Kafka-Offsets nicht abgerufen werden. Der Standardwert ist `3`.
+ `"retryIntervalMs"`: (Optional) Die Wartezeit in Millisekunden, bevor Sie erneut versuchen, Kafka-Offsets abzurufen. Der Standardwert ist `10`.
+ `"maxOffsetsPerTrigger"`: (Optional) Die Ratengrenze für die maximale Anzahl von Offsets, die pro Triggerintervall verarbeitet werden. Die angegebene Gesamtzahl der Offsets wird proportional auf `topicPartitions`von verschiedenen Volumes aufgeteilt. Der Standardwert ist null, was bedeutet, dass der Verbraucher alle Offsets bis zum bekannten letzten Offset liest.
+ `"minPartitions"`: (Optional) Die gewünschte Mindestanzahl an Partitionen, die von Kafka gelesen werden sollen. Der Standardwert ist null, was bedeutet, dass die Anzahl der Spark-Partitionen gleich der Anzahl der Kafka-Partitionen ist.
+ `"includeHeaders"`: (Optional) Gibt an, ob die Kafka-Header eingeschlossen werden sollen. Wenn die Option auf „true“ gesetzt ist, enthält die Datenausgabe eine zusätzliche Spalte mit dem Namen „glue\$1streaming\$1kafka\$1headers“ mit dem Typ `Array[Struct(key: String, value: String)]`. Der Standardwert ist „false“. Diese Option ist nur in AWS Glue Version 3.0 oder höher verfügbar.
+ `"schema"`: (Erforderlich, wenn inferSchema auf „false“ festgelegt ist) Das Schema, das zur Verarbeitung der Nutzlast verwendet werden soll. Wenn die Klassifizierung `avro` ist, muss das bereitgestellte Schema im Avro-Schemaformat vorliegen. Wenn die Klassifizierung nicht `avro` ist, muss das bereitgestellte Schema im DDL-Schemaformat vorliegen.
Im Folgenden finden Sie Beispiele für Schemata.
------
#### [ Example in DDL schema format ]
```
'column1' INT, 'column2' STRING , 'column3' FLOAT
```
------
#### [ Example in Avro schema format ]
```
{
"type":"array",
"items":
{
"type":"record",
"name":"test",
"fields":
[
{
"name":"_id",
"type":"string"
},
{
"name":"index",
"type":
[
"int",
"string",
"float"
]
}
]
}
}
```
------
+ `"inferSchema"`: (Optional) Der Standardwert ist „false“. Wenn auf „true“ gesetzt, wird das Schema zur Laufzeit von der Nutzlast in `foreachbatch` erkannt.
+ `"avroSchema"`: (Veraltet) Parameter, der verwendet wird, um ein Schema von Avro-Daten anzugeben, wenn das Avro-Format verwendet wird. Dieser Parameter ist jetzt veraltet. Verwenden Sie den Parameter `schema`.
+ `"addRecordTimestamp"`: (Optional) Wenn diese Option auf „true“ gesetzt ist, enthält die Datenausgabe eine zusätzliche Spalte mit dem Namen „\$1\$1src\$1timestamp“, die den Zeitpunkt angibt, zu dem der entsprechende Datensatz beim Thema eingegangen ist. Der Standardwert von "false". Diese Option wird in AWS Glue Version 4.0 oder höher unterstützt.
+ `"emitConsumerLagMetrics"`: (Optional) Wenn die Option auf „true“ gesetzt ist, werden für jeden Batch die Metriken für den Zeitraum zwischen dem ältesten Datensatz, den das Thema empfangen hat, und dem Zeitpunkt, zu dem er eingeht, ausgegeben. AWS Glue CloudWatch Der Name der Metrik lautet „glue.driver.streaming“. maxConsumerLagInMs“. Der Standardwert von "false". Diese Option wird in AWS Glue Version 4.0 oder höher unterstützt.
Verwenden Sie beim Schreiben die folgenden Verbindungsoptionen mit `"connectionType": "kafka"`:
+ `"connectionName"`(Erforderlich) Name der AWS Glue-Verbindung, die für die Verbindung mit dem Kafka-Cluster verwendet wird (ähnlich der Kafka-Quelle).
+ `"topic"` (Erforderlich) Wenn eine Themenspalte vorhanden ist, wird ihr Wert als Thema verwendet, wenn die angegebene Zeile in Kafka geschrieben wird, sofern die Themenkonfigurationsoption nicht festgelegt ist. Das heißt, die `topic`-Konfigurationsoption überschreibt die Themenspalte.
+ `"partition"` (Optional) Wenn eine gültige Partitionsnummer angegeben ist, wird diese `partition` beim Senden des Datensatzes verwendet.
Wenn keine Partition angegeben ist, aber ein `key` vorhanden ist, wird eine Partition anhand eines Hashs des Schlüssels ausgewählt.
Falls `key` weder noch vorhanden `partition` ist, wird eine Partition auf der Grundlage von Sticky-Partitionierung ausgewählt, wenn für die Partition mindestens batch.size Bytes erzeugt werden.
+ `"key"` (Optional) Wird für die Partitionierung verwendet, wenn `partition` NULL ist.
+ `"classification"` (Optional) Das von den Daten im Datensatz verwendete Dateiformat. Wir unterstützen nur JSON, CSV und Avro.
Mit dem Avro-Format können wir ein benutzerdefiniertes AvroSchema für die Serialisierung bereitstellen. Beachten Sie jedoch, dass dieses auch in der Quelle für die Deserialisierung bereitgestellt werden muss. Andernfalls verwendet es standardmäßig den Apache AvroSchema für die Serialisierung.
[Darüber hinaus können Sie die Kafka-Senke nach Bedarf optimieren, indem Sie die Konfigurationsparameter des Kafka-Producers aktualisieren.](https://kafka.apache.org/documentation/#producerconfigs) Beachten Sie, dass es keine Zulassungsliste für Verbindungsoptionen gibt, da alle Schlüssel-Wert-Paare unverändert auf der Senke gespeichert werden.
Es gibt jedoch eine kleine Sperrliste von Optionen, die nicht wirksam werden. Weitere Informationen finden Sie unter [Kafka-spezifische Konfigurationen](https://spark.apache.org/docs/latest/structured-streaming-kafka-integration.html).
# Azure-Cosmos-DB-Verbindungen
Sie können AWS Glue for Spark verwenden, um mithilfe der NoSQL-API in AWS Glue 4.0 und späteren Versionen aus vorhandenen Containern in Azure Cosmos DB zu lesen und in diese zu schreiben. Sie können definieren, was mit einer SQL-Abfrage aus Azure Cosmos DB gelesen werden soll. Sie stellen mithilfe eines Azure Cosmos DB-Schlüssels, der über eine AWS Glue-Verbindung gespeichert ist, eine Verbindung zu Azure Cosmos DB her. AWS Secrets Manager
Weitere Informationen zu Azure Cosmos DB for NoSQL finden Sie in der [Azure-Dokumentation](https://learn.microsoft.com/en-us/azure/cosmos-db/nosql/).
## Konfigurieren von Azure-Cosmos DB-Verbindungen
Um von AWS Glue aus eine Verbindung mit Azure Cosmos DB herzustellen, müssen Sie Ihren Azure Cosmos DB-Schlüssel erstellen und in einem AWS Secrets Manager Geheimnis speichern und dieses Geheimnis dann einer Azure Cosmos DB AWS Glue-Verbindung zuordnen.
**Voraussetzungen:**
+ In Azure müssen Sie einen Azure Cosmos DB-Schlüssel für die Verwendung durch AWS Glue identifizieren oder generieren. `cosmosKey` Weitere Informationen finden Sie unter [Sicherer Zugriff auf Daten in Azure Cosmos DB](https://learn.microsoft.com/en-us/azure/cosmos-db/secure-access-to-data?tabs=using-primary-key) in der Azure-Dokumentation.
**Eine Verbindung zu Azure Cosmos DB konfigurieren Sie wie folgt:**
1. Erstellen Sie AWS Secrets Manager unter Verwendung Ihres Azure Cosmos DB-Schlüssels ein Geheimnis. Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial, das in der AWS Secrets Manager Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) verfügbar ist. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `spark.cosmos.accountKey` mit dem Wert. *cosmosKey*
1. Stellen Sie in der AWS Glue-Konsole eine Verbindung her, indem Sie den Schritten unter folgen[AWS Glue Verbindung hinzufügen](console-connections.md). Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für die future Verwendung in AWS Glue bei. *connectionName*
+ Wählen Sie als **Verbindungstyp** Azure Cosmos DB aus.
+ Wenn Sie ein **AWS Geheimnis** auswählen, geben Sie an*secretName*.
Nachdem Sie eine AWS Glue Azure Cosmos DB-Verbindung erstellt haben, müssen Sie die folgenden Schritte ausführen, bevor Sie Ihren AWS Glue-Job ausführen:
+ Erteilen Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle *secretName* Leserechte.
+ Stellen *connectionName* Sie in Ihrer AWS Glue-Job-Konfiguration eine **zusätzliche Netzwerkverbindung** bereit.
## Lesen aus Container in Azure Cosmos DB für NoSQL
**Voraussetzungen:**
+ Ein Container in Azure Cosmos DB für NoSQL, aus dem Sie lesen möchten. Sie benötigen Identifikationsinformationen für den Container.
Ein Container in Azure Cosmos DB für NoSQL wird anhand seiner Datenbank und seines Containers identifiziert. Sie müssen die Datenbank- und Container-Namen angeben*cosmosContainerName*, wenn Sie eine Verbindung zur Azure Cosmos for NoSQL-API herstellen. *cosmosDBName*
+ Eine AWS Glue Azure Cosmos DB-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkstandortinformationen bereitstellt. Führen Sie dazu die Schritte im vorherigen Verfahren zum *Konfigurieren einer Verbindung zu Azure Cosmos DB* aus. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
azurecosmos_read = glueContext.create_dynamic_frame.from_options(
connection_type="azurecosmos",
connection_options={
"connectionName": connectionName,
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName,
}
)
```
Sie können auch eine SELECT-SQL-Abfrage angeben, um die an Ihre zurückgegebenen Ergebnisse zu filtern DynamicFrame. Sie müssen `query` konfigurieren.
Beispiel:
```
azurecosmos_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="azurecosmos",
connection_options={
"connectionName": "connectionName",
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName,
"spark.cosmos.read.customQuery": "query"
}
)
```
## Schreiben in Container in Azure Cosmos DB für NoSQL
In diesem Beispiel werden Informationen aus einer vorhandenen DynamicFrame Datenbank *dynamicFrame* in Azure Cosmos DB geschrieben. Wenn der Container bereits Informationen enthält, hängt AWS Glue Daten von Ihrem DynamicFrame an. Wenn die Informationen im Container ein anderes Schema haben als die Informationen, die Sie schreiben, treten Fehler auf.
**Voraussetzungen:**
+ Eine Azure-Cosmos-DB-Tabelle, in die Sie schreiben möchten. Sie benötigen Identifikationsinformationen für den Container. **Sie müssen den Container erstellen, bevor Sie die Verbindungsmethode aufrufen.**
Ein Container in Azure Cosmos DB für NoSQL wird anhand seiner Datenbank und seines Containers identifiziert. Sie müssen die Datenbank- und Container-Namen angeben*cosmosContainerName*, wenn Sie eine Verbindung zur Azure Cosmos for NoSQL-API herstellen. *cosmosDBName*
+ Eine AWS Glue Azure Cosmos DB-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkstandortinformationen bereitstellt. Führen Sie dazu die Schritte im vorherigen Verfahren zum *Konfigurieren einer Verbindung zu Azure Cosmos DB* aus. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
azurecosmos_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="azurecosmos",
connection_options={
"connectionName": connectionName,
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName
)
```
## Referenz zur Azure-Cosmos-DB-Verbindungsoption
+ `connectionName` – Erforderlich. Wird für Lesen/Schreiben verwendet. Der Name einer AWS Glue Azure Cosmos DB-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkstandortinformationen für Ihre Verbindungsmethode bereitstellt.
+ `spark.cosmos.database` – Erforderlich. Wird für Lesen/Schreiben verwendet. Zulässige Werte: Datenbanknamen. Name der Azure Cosmos DB für NoSQL-Datenbank.
+ `spark.cosmos.container` – Erforderlich. Wird für Lesen/Schreiben verwendet. Zulässige Werte: Containernamen. Name des Containers in Azure Cosmos DB für NoSQL.
+ `spark.cosmos.read.customQuery` – Wird zum Lesen verwendet. Gültige Werte: SELECT-SQL-Abfragen. Benutzerdefinierte Abfrage zur Auswahl von Dokumenten, die gelesen werden sollen.
# Azure-SQL-Verbindungen
Sie können AWS Glue for Spark verwenden, um aus Tabellen auf verwalteten Azure SQL-Instanzen in AWS Glue 4.0 und späteren Versionen zu lesen und in Tabellen zu schreiben. Sie können definieren, was mit einer SQL-Abfrage aus Azure SQL gelesen werden soll. Sie stellen mithilfe von Benutzer- und Kennwortanmeldeinformationen, die AWS Secrets Manager über eine AWS Glue-Verbindung gespeichert sind, eine Verbindung zu Azure SQL her.
Weitere Informationen zu Azure SQL finden Sie in der [Azure-SQL-Dokumentation](https://azure.microsoft.com/en-us/products/azure-sql).
## Konfigurieren von Azure-SQL-Verbindungen
Um von AWS Glue aus eine Verbindung zu Azure SQL herzustellen, müssen Sie Ihre Azure SQL-Anmeldeinformationen erstellen und in einem AWS Secrets Manager geheimen Ordner speichern und dieses Geheimnis dann einer Azure SQL AWS Glue-Verbindung zuordnen.
**Eine Verbindung zu Azure SQL konfigurieren Sie wie folgt:**
1. Erstellen Sie unter Verwendung Ihrer Azure SQL-Anmeldeinformationen ein Geheimnis. AWS Secrets Manager Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial, das in der AWS Secrets Manager Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) verfügbar ist. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `user` mit dem Wert. *azuresqlUsername*
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `password` mit dem Wert. *azuresqlPassword*
1. Stellen Sie in der AWS Glue-Konsole eine Verbindung her, indem Sie den Schritten unter folgen[AWS Glue Verbindung hinzufügen](console-connections.md). Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für die future Verwendung in AWS Glue bei. *connectionName*
+ Wählen Sie als **Verbindungstyp** Azure SQL aus.
+ Wenn Sie eine **Azure-SQL-URL** angeben, geben Sie eine JDBC-Endpunkt-URL an.
Die URL muss das folgende Format aufweisen: `jdbc:sqlserver://databaseServerName:databasePort;databaseName=azuresqlDBname;`.
AWS Glue benötigt die folgenden URL-Eigenschaften:
+ `databaseName` – Eine Standarddatenbank in Azure SQL, mit der eine Verbindung hergestellt werden kann.
Weitere Informationen zu JDBC URLs für Azure SQL Managed Instances finden Sie in der [Microsoft-Dokumentation](https://learn.microsoft.com/en-us/sql/connect/jdbc/building-the-connection-url?view=azuresqldb-mi-current).
+ Geben Sie bei der Auswahl eines **AWS Geheimnisses Folgendes** an: *secretName*
Nachdem Sie eine AWS Glue Azure SQL-Verbindung erstellt haben, müssen Sie die folgenden Schritte ausführen, bevor Sie Ihren AWS Glue-Job ausführen:
+ Erteilen Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle *secretName* Leserechte.
+ Stellen *connectionName* Sie in Ihrer AWS Glue-Job-Konfiguration eine **zusätzliche Netzwerkverbindung** bereit.
## Lesen in Azure-SQL-Tabellen
**Voraussetzungen:**
+ Eine Azure-SQL-Tabelle, aus der gelesen werden soll. Sie benötigen Identifikationsinformationen für die Tabelle *databaseName* und*tableIdentifier*.
Eine Azure-SQL-Tabelle wird anhand ihrer Datenbank, ihres Schemas und ihres Tabellennamens identifiziert. Sie müssen den Datenbanknamen und den Tabellennamen angeben, wenn Sie eine Verbindung zu Azure SQL herstellen. Sie müssen auch das Schema angeben, falls es sich nicht um das Standardschema „public“ handelt. Die Datenbank wird über eine URL-Eigenschaft in*connectionName*, ein Schema und einen Tabellennamen über die bereitgestellt`dbtable`.
+ Eine AWS Glue Azure SQL-Verbindung, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Gehen Sie wie im vorherigen Verfahren beschrieben vor, *um eine Verbindung zu Azure SQL zu konfigurieren*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
azuresql_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier"
}
)
```
Sie können auch eine SELECT-SQL-Abfrage angeben, um die an Ihre zurückgegebenen Ergebnisse zu filtern DynamicFrame. Sie müssen `query` konfigurieren.
Beispiel:
```
azuresql_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Schreiben in Azure-SQL-Tabellen
In diesem Beispiel werden Informationen aus einer vorhandenen DynamicFrame Datei *dynamicFrame* in Azure SQL geschrieben. Wenn die Tabelle bereits Informationen enthält, hängt AWS Glue Daten von Ihnen DynamicFrame an.
**Voraussetzungen:**
+ Eine Azure-SQL-Tabelle, in die Sie schreiben möchten. Sie benötigen Identifikationsinformationen für die Tabelle, *databaseName* und*tableIdentifier*.
Eine Azure-SQL-Tabelle wird anhand ihrer Datenbank, ihres Schemas und ihres Tabellennamens identifiziert. Sie müssen den Datenbanknamen und den Tabellennamen angeben, wenn Sie eine Verbindung zu Azure SQL herstellen. Sie müssen auch das Schema angeben, falls es sich nicht um das Standardschema „public“ handelt. Die Datenbank wird über eine URL-Eigenschaft in*connectionName*, ein Schema und einen Tabellennamen über die bereitgestellt`dbtable`.
+ Azure-SQL-Authentifizierungsinformationen. Gehen Sie wie im vorherigen Verfahren beschrieben vor, *um eine Verbindung zu Azure SQL zu konfigurieren*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
azuresql_write = glueContext.write_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier"
}
)
```
## Referenz zur Azure-SQL-Verbindungsoption
+ `connectionName` – Erforderlich. Wird für Lesen/Schreiben verwendet. Der Name einer AWS Glue Azure SQL-Verbindung, die so konfiguriert ist, dass sie Authentifizierungsinformationen für Ihre Verbindungsmethode bereitstellt.
+ `databaseName` – Wird zum Lesen/Schreiben verwendet. Zulässige Werte: Azure-SQL-Datenbanknamen. Der Name der Datenbank in Azure SQL, mit der eine Verbindung hergestellt werden soll.
+ `dbtable` – Zum Schreiben erforderlich, zum Lesen erforderlich, sofern `query` nicht angegeben ist. Wird für Read/Write. Valid Values: Names of Azure SQL tables, or period separated schema/table Namenskombinationen verwendet. Wird verwendet, um die Tabelle und das Schema anzugeben, die die Tabelle identifizieren, zu der eine Verbindung hergestellt werden soll. Das Standardschema ist „public“. Wenn sich Ihre Tabelle nicht in einem Standardschema befindet, geben Sie diese Informationen in das Formular `schemaName.tableName` ein.
+ `query` – Wird zum Lesen verwendet. Eine Transact-SQL-SELECT-Abfrage, die definiert, was beim Lesen aus Azure SQL abgerufen werden soll. Weitere Informationen finden Sie in der [ Microsoft-Dokumentation](https://learn.microsoft.com/en-us/sql/t-sql/queries/select-transact-sql?view=azuresqldb-mi-current).
# BigQuery Verbindungen
In AWS Glue 4.0 und späteren Versionen können Sie Glue for Spark verwenden, um aus Tabellen BigQuery in AWS Google zu lesen und in Tabellen zu schreiben. Sie können BigQuery mit einer Google-SQL-Abfrage aus lesen. Sie stellen eine Verbindung BigQuery mit Anmeldeinformationen her, AWS Secrets Manager die über eine AWS Glue-Verbindung gespeichert sind.
Weitere Informationen zu Google BigQuery finden Sie auf der [Google BigQuery Cloud-Website](https://cloud.google.com/bigquery).
## BigQuery Verbindungen konfigurieren
Um BigQuery von AWS Glue aus eine Verbindung zu Google herzustellen, müssen Sie Ihre Anmeldeinformationen für die Google Cloud Platform erstellen und in einem AWS Secrets Manager geheimen Ordner speichern und dieses Geheimnis dann mit einer Google BigQuery AWS Glue-Verbindung verknüpfen.
**So konfigurieren Sie eine Verbindung zu BigQuery:**
1. Erstellen und identifizieren Sie in der Google Cloud Platform relevante Ressourcen:
+ Erstellen oder identifizieren Sie ein GCP-Projekt mit BigQuery Tabellen, zu denen Sie eine Verbindung herstellen möchten.
+ Aktivieren Sie die BigQuery API. Weitere Informationen finden Sie unter [Verwenden der BigQuery Storage Read API zum Lesen von Tabellendaten](https://cloud.google.com/bigquery/docs/reference/storage/#enabling_the_api).
1. Erstellen und exportieren Sie in Google Cloud Platform Anmeldeinformationen für ein Dienstkonto:
Sie können den Assistenten für BigQuery Anmeldeinformationen verwenden, um diesen Schritt zu beschleunigen: Anmeldeinformationen [erstellen](https://console.cloud.google.com/apis/credentials/wizard?api=bigquery.googleapis.com).
Folgen Sie der Anleitung unter [Dienstkonten erstellen](https://cloud.google.com/iam/docs/service-accounts-create), um ein Dienstkonto in GCP zu erstellen.
+ Wählen Sie bei der **Projektauswahl** das Projekt aus, das Ihre BigQuery Tabelle enthält.
+ Wenn Sie GCP-IAM-Rollen für Ihr Dienstkonto auswählen, fügen Sie eine Rolle hinzu oder erstellen Sie eine Rolle, die entsprechende Berechtigungen zum Ausführen von BigQuery Jobs zum Lesen, Schreiben oder Erstellen BigQuery von Tabellen gewährt.
Folgen Sie der Anleitung unter [Einen Dienstkontoschlüssel erstellen](https://cloud.google.com/iam/docs/keys-create-delete#creating), um Anmeldeinformationen für Ihr Dienstkonto zu erstellen.
+ Wählen Sie für den Schlüsseltyp **JSON** aus.
Sie sollten jetzt eine JSON-Datei mit Anmeldeinformationen für Ihr Dienstkonto heruntergeladen haben. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"type": "service_account",
"project_id": "*****",
"private_key_id": "*****",
"private_key": "*****",
"client_email": "*****",
"client_id": "*****",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://oauth2.googleapis.com/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "*****",
"universe_domain": "googleapis.com"
}
```
1. Laden Sie die JSON-Datei mit Ihren Anmeldeinformationen an einem entsprechend sicheren Amazon-S3-Speicherort hoch. Behalten Sie den Pfad zur Datei *s3secretpath* für future Schritte bei.
1. Erstellen Sie AWS Secrets Manager unter mit Ihren Anmeldedaten für die Google Cloud Platform einen geheimen Schlüssel. Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial, das in der AWS Secrets Manager Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) verfügbar ist. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
Geben Sie beim Erstellen von Key/value Paaren die Schlüssel und Werte wie folgt an:
+ Geben Sie für `token_uri` `client_x509_cert_url``private_key_id`,`project_id`,`universe_domain`,`auth_provider_x509_cert_url`,`auth_uri`,`client_email`, `private_key``type`, `client_id` Schlüssel die entsprechenden Werte in der heruntergeladenen JSON-Datei an.
+ Geben Sie für `spark.hadoop.google.cloud.auth.service.account.json.keyfile` Schlüssel den an*s3secretpath*.
1. Stellen AWS Sie im Glue-Datenkatalog eine Verbindung her, indem Sie die Schritte unter befolgen[AWS Glue Verbindung hinzufügen](console-connections.md). Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für den nächsten Schritt bei. *connectionName*
+ Wählen Sie bei der Auswahl eines **Verbindungstyps** Google aus BigQuery.
+ Geben Sie bei der Auswahl eines **AWS Geheimnisses** Folgendes an*secretName*.
1. Erteilen Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle *secretName* Leserechte.
1. Stellen *connectionName* Sie in Ihrer AWS Glue-Job-Konfiguration eine **zusätzliche Netzwerkverbindung** bereit.
## Aus BigQuery Tabellen lesen
**Voraussetzungen:**
+ Eine BigQuery Tabelle, aus der Sie lesen möchten. Sie benötigen die BigQuery Tabellen- und Datensatznamen im Formular`[dataset].[table]`. Nennen wir das*tableName*.
+ Das Abrechnungsprojekt für die BigQuery Tabelle. Sie benötigen den Namen des Projekts,*parentProject*. Wenn es kein übergeordnetes Fakturierungsprojekt gibt, verwenden Sie das Projekt, das die Tabelle enthält.
+ BigQuery Informationen zur Authentifizierung. Gehen Sie wie folgt vor*, um Ihre Verbindungsdaten mit AWS Glue zu verwalten*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
bigquery_read = glueContext.create_dynamic_frame.from_options(
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"sourceType": "table",
"table": "tableName",
}
```
Sie können auch eine Abfrage angeben, um die an Sie zurückgegebenen Ergebnisse zu filtern DynamicFrame. Sie müssen `query`, `sourceType`, `viewsEnabled` und `materializationDataset` konfigurieren.
Beispiel:
**Zusätzliche Voraussetzungen:**
Sie müssen einen BigQuery Datensatz erstellen oder identifizieren*materializationDataset*, in den Sie materialisierte Ansichten für Ihre Abfragen schreiben BigQuery können.
Sie müssen Ihrem Dienstkonto die entsprechenden GCP-IAM-Berechtigungen gewähren, um darin Tabellen erstellen zu können. *materializationDataset*
```
glueContext.create_dynamic_frame.from_options(
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"materializationDataset": materializationDataset,
"parentProject": "parentProject",
"viewsEnabled": "true",
"sourceType": "query",
"query": "select * from bqtest.test"
}
)
```
## In Tabellen schreiben BigQuery
In diesem Beispiel wird direkt in den BigQuery Dienst geschrieben. BigQuery unterstützt auch die „indirekte“ Schreibmethode. Weitere Informationen zur Konfiguration indirekter Schreibvorgänge finden Sie unter [Verwenden Sie indirektes Schreiben mit Google BigQuery](#aws-glue-programming-etl-connect-bigquery-indirect-write).
**Voraussetzungen:**
+ Eine BigQuery Tabelle, in die Sie schreiben möchten. Sie benötigen die BigQuery Tabellen- und Datensatznamen im Formular`[dataset].[table]`. Sie können auch einen neuen Tabellennamen angeben, der automatisch erstellt wird. Nennen wir das*tableName*.
+ Das Abrechnungsprojekt für die BigQuery Tabelle. Sie benötigen den Namen des Projekts,*parentProject*. Wenn es kein übergeordnetes Fakturierungsprojekt gibt, verwenden Sie das Projekt, das die Tabelle enthält.
+ BigQuery Informationen zur Authentifizierung. Gehen Sie wie folgt vor*, um Ihre Verbindungsdaten mit AWS Glue zu verwalten*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
bigquery_write = glueContext.write_dynamic_frame.from_options(
frame=frameToWrite,
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"writeMethod": "direct",
"table": "tableName",
}
)
```
## BigQuery Referenz zur Verbindungsoption
+ `project` – Standard: Standard für das Google Cloud-Dienstkonto. Wird für Lesen/Schreiben verwendet. Der Name eines Google Cloud-Projekts, das mit Ihrer Tabelle verknüpft ist.
+ `table` – (Erforderlich) Wird zum Lesen/Schreiben verwendet. Der Name Ihrer BigQuery Tabelle im Format`[[project:]dataset.]`.
+ `dataset` – Erforderlich, wenn nicht über die Option `table` definiert. Wird für Lesen/Schreiben verwendet. Der Name des Datensatzes, der Ihre BigQuery Tabelle enthält.
+ `parentProject` – Standard: Standard für das Google Cloud-Dienstkonto. Wird für Lesen/Schreiben verwendet. Der Name eines Google Cloud-Projekts, das mit `project` verknüpft ist und für die Fakturierung verwendet wird.
+ `sourceType` – Wird zum Lesen verwendet. Beim Lesen erforderlich. Gültige Werte:`table`, `query` Informiert AWS Glue darüber, ob Sie nach Tabelle oder nach Abfrage lesen werden.
+ `materializationDataset` – Wird zum Lesen verwendet. Gültige Werte: Zeichenfolgen. Der Name eines BigQuery Datensatzes, der zum Speichern von Materialisierungen für Ansichten verwendet wird.
+ `viewsEnabled` – Wird zum Lesen verwendet. Standard: falsch. Zulässige Werte: true, false. Konfiguriert, ob Ansichten verwendet BigQuery werden.
+ `query` – Wird zum Lesen verwendet. Wird verwendet, wenn `viewsEnabled` „true“ ist. Eine GoogleSQL-DQL-Abfrage.
+ `temporaryGcsBucket` – Wird zum Schreiben verwendet. Erforderlich, wenn `writeMethod` auf Standard (`indirect`) eingestellt ist. Name eines Google Cloud Storage-Buckets, in dem beim Schreiben eine Zwischenform Ihrer Daten gespeichert wird. BigQuery
+ `writeMethod` – Standardwert: `indirect`. Zulässige Werte: `direct`, `indirect`. Wird zum Schreiben verwendet. Gibt die Methode an, mit der Ihre Daten geschrieben werden.
+ Wenn auf gesetzt`direct`, schreibt Ihr Connector mithilfe der BigQuery Storage Write-API.
+ Wenn auf gesetzt`indirect`, schreibt Ihr Connector in Google Cloud Storage und überträgt ihn dann BigQuery mithilfe eines Ladevorgangs an Google Cloud Storage. Ihr Google Cloud-Dienstkonto benötigt entsprechende GCS-Berechtigungen.
## Verwenden Sie indirektes Schreiben mit Google BigQuery
In diesem Beispiel wird indirektes Schreiben verwendet, bei dem Daten in Google Cloud Storage geschrieben und nach Google kopiert BigQuery werden.
**Voraussetzungen:**
Sie benötigen einen temporären Google Cloud Storage-Bucket,*temporaryBucket*.
Für den Zugriff auf die GCP-IAM-Rolle für das GCP-Dienstkonto von AWS Glue sind entsprechende GCS-Berechtigungen erforderlich. *temporaryBucket*
**Zusätzliche Konfiguration:**
**Um indirektes Schreiben zu konfigurieren mit: BigQuery**
1. Bewerten Sie [BigQuery Verbindungen konfigurieren](#aws-glue-programming-etl-connect-bigquery-configure) und suchen oder laden Sie die JSON-Datei mit Ihren GCP-Anmeldeinformationen erneut herunter. Identifizieren Sie *secretName* das AWS Secrets Manager Geheimnis für die Google BigQuery AWS Glue-Verbindung, die in Ihrem Job verwendet wird.
1. Laden Sie die JSON-Datei mit Ihren Anmeldeinformationen an einem entsprechend sicheren Amazon-S3-Speicherort hoch. Behalten Sie den Pfad zur Datei *s3secretpath* für future Schritte bei.
1. Bearbeiten*secretName*, `spark.hadoop.google.cloud.auth.service.account.json.keyfile` Schlüssel hinzufügen. Legen Sie den Wert auf *s3secretpath* fest.
1. Erteilen Sie Ihrem AWS Glue-Job Amazon S3 *s3secretpath* IAM-Zugriffsberechtigungen.
Sie können jetzt den Speicherort Ihres temporären GCS-Bucket für Ihre Schreibmethode angeben. Sie müssen `writeMethod` nicht angeben, da `indirect` üblicherweise die Standardeinstellung ist.
```
bigquery_write = glueContext.write_dynamic_frame.from_options(
frame=frameToWrite,
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"temporaryGcsBucket": "temporaryBucket",
"table": "tableName",
}
)
```
# JDBC-Verbindungen
Bestimmte, in der Regel relationale Datenbanktypen unterstützen die Verbindung über den JDBC-Standard. Weitere Informationen zu JDBC finden Sie in der [Java JDBC](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/) API-Dokumentation. AWS Glue unterstützt nativ die Verbindung zu bestimmten Datenbanken über ihre JDBC-Konnektoren — die JDBC-Bibliotheken werden in Glue Spark-Jobs bereitgestellt. AWS Wenn Sie mithilfe von AWS -Glue-Bibliotheken eine Verbindung zu diesen Datenbanktypen herstellen, haben Sie Zugriff auf eine Reihe von Standardoptionen.
Zu den JDBC-connectionType-Werten gehören:
+ `"connectionType": "sqlserver"`: Bezeichnet eine Verbindung zu einer Microsoft SQL Server-Datenbank.
+ `"connectionType": "mysql"`: Bezeichnet eine Verbindung zu einer MySQL-Datenbank.
+ `"connectionType": "oracle"`: Bezeichnet eine Verbindung zu einer Oracle-Datenbank.
+ `"connectionType": "postgresql"`: Bezeichnet eine Verbindung zu einer PostgreSQL-Datenbank.
+ `"connectionType": "redshift"`: Bezeichnet eine Verbindung zu einer Amazon-Redshift-Datenbank. Weitere Informationen finden Sie unter [Redshift-Verbindungen](aws-glue-programming-etl-connect-redshift-home.md).
In der folgenden Tabelle sind die JDBC-Treiberversionen aufgeführt, die AWS Glue unterstützt.
| Produkt | JDBC-Treiberversionen für Glue 5.1 | JDBC-Treiberversionen für Glue 5.0 | JDBC-Treiberversionen für Glue 4.0 | JDBC-Treiberversionen für Glue 3.0 | JDBC-Treiberversionen für Glue 0.9, 1.0, 2.0 |
| --- | --- | --- | --- | --- | --- |
| Microsoft SQL Server | 10.2.0 | 10.2.0 | 9.4,0 | 7.x | 6.x |
| MySQL | 8,0,33 | 8,0,33 | 8.0.23 | 8.0.23 | 5.1 |
| Oracle-Datenbank | 23.3.0.23.09 | 23.3.0.23,09 | 21,7 | 21,1 | 11.2 |
| PostgreSQL | 42,7,3 | 42,7,3 | 42,3,6 | 42,2,18 | 42.1.x |
| Amazon Redshift \$1 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 |
\$1 Für den Amazon Redshift Redshift-Verbindungstyp werden alle anderen name/value Optionspaare, die in den Verbindungsoptionen für eine JDBC-Verbindung enthalten sind, einschließlich Formatierungsoptionen, direkt an das zugrunde liegende SparkSQL übergeben. DataSource In AWS Glue with Spark-Jobs in AWS Glue 4.0 und späteren Versionen verwendet der native AWS Glue-Connector für Amazon Redshift die Amazon Redshift Redshift-Integration für Apache Spark. Weitere Informationen finden Sie unter [Amazon-Redshift-Integration für Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). In früheren Versionen finden Sie Informationen zur [Amazon-Redshift-Datenquelle für Spark](https://github.com/databricks/spark-redshift).
Informationen zum Konfigurieren Ihrer Amazon VPC für die Verbindung mit Amazon-RDS-Datenspeichern über JDBC finden Sie unter [Einrichten von Amazon VPC für JDBC-Verbindungen zu Amazon-RDS-Datenspeichern von AWS Glue](setup-vpc-for-glue-access.md).
**Anmerkung**
AWS Glue-Jobs werden während eines Laufs nur einem Subnetz zugeordnet. Dies kann sich auf Ihre Fähigkeit auswirken, über denselben Auftrag eine Verbindung zu mehreren Datenquellen herzustellen. Dieses Verhalten ist nicht auf JDBC-Quellen beschränkt.
**Topics**
+ [Referenz zur JDBC-Verbindungsoption](#aws-glue-programming-etl-connect-jdbc)
+ [sampleQuery verwenden](#aws-glue-programming-etl-jdbc-samplequery)
+ [Benutzerdefinierten JDBC-Treiber verwenden](#aws-glue-programming-etl-jdbc-custom-driver)
+ [Parallel aus JDBC-Tabellen lesen](run-jdbc-parallel-read-job.md)
+ [Einrichten von Amazon VPC für JDBC-Verbindungen zu Amazon-RDS-Datenspeichern von AWS Glue](setup-vpc-for-glue-access.md)
## Referenz zur JDBC-Verbindungsoption
Wenn Sie bereits eine JDBC AWS Glue-Verbindung definiert haben, können Sie die darin definierten Konfigurationseigenschaften wie URL, Benutzer und Passwort wiederverwenden. Sie müssen sie also nicht im Code als Verbindungsoptionen angeben. Diese Funktion ist in AWS Glue 3.0 und späteren Versionen verfügbar. Verwenden Sie dazu die folgenden Verbindungseigenschaften:
+ `"useConnectionProperties"`: Setzen Sie den Wert auf „true“, um anzugeben, dass Sie die Konfiguration von einer Verbindung aus verwenden möchten.
+ `"connectionName"`: Geben Sie den Verbindungsnamen ein, aus dem die Konfiguration abgerufen werden soll. Die Verbindung muss in derselben Region wie der Auftrag definiert sein.
Verwenden Sie diese Verbindungsoptionen mit JDBC-Verbindungen:
+ `"url"`: (Erforderlich) Die JDBC-URL für die Datenbank.
+ `"dbtable"`: (Erforderlich) Die Datenbanktabelle, aus der gelesen werden soll. Bei JDBC-Datenspeichern, die von Schemata innerhalb einer Datenbank unterstützen, geben Sie `schema.table-name` an. Wenn kein Schema angegeben ist, wird der Standardwert "öffentliches" Schema verwendet.
+ `"user"`: (Erforderlich) Der Benutzername, der beim herstellen der Verbindung verwendet werden soll.
+ `"password"`: (Erforderlich) Das Passwort für die Verbindung.
+ (Optional) Mit den folgenden Optionen können Sie einen benutzerdefinierten JDBC-Treiber bereitstellen. Verwenden Sie diese Optionen, wenn Sie einen Treiber verwenden müssen, den AWS Glue nicht nativ unterstützt.
ETL-Aufträge können verschiedene JDBC-Treiberversionen für die Datenquelle und das Ziel verwenden, selbst wenn Quelle und Ziel dasselbe Datenbankprodukt sind. Auf diese Weise können Sie Daten zwischen Quell- und Zieldatenbanken mit unterschiedlichen Versionen migrieren. Um diese Optionen zu verwenden, müssen Sie zuerst die JAR-Datei des JDBC-Treibers in Amazon S3 hochladen.
+ `"customJdbcDriverS3Path"`: Der Amazon-S3-Pfad des benutzerdefinierten JDBC-Treibers.
+ `"customJdbcDriverClassName"`: Der Klassenname des JDBC-Treibers.
+ `"bulkSize"`: (Optional) Wird verwendet, um parallele Inserts zu konfigurieren, um Massenladungen in JDBC-Ziele zu beschleunigen. Geben Sie einen ganzzahligen Wert für den Parallelitätsgrad an, der beim Schreiben oder Einfügen von Daten verwendet werden soll. Diese Option ist hilfreich, um die Leistung beim Schreiben in Datenbanken wie das Arch User Repository (AUR) zu verbessern.
+ `"hashfield"` (Optional) Eine Zeichenfolge, die zur Angabe des Namens einer Spalte in der JDBC-Tabelle verwendet wird, die zum Aufteilen der Daten in Partitionen beim parallelen Lesen aus JDBC-Tabellen verwendet werden soll. Geben Sie „hashfield“ ODER „hashexpression“ an. Weitere Informationen finden Sie unter [Parallel aus JDBC-Tabellen lesen](run-jdbc-parallel-read-job.md).
+ `"hashexpression"` (Optional) Eine SQL-Auswahlklausel, die eine ganze Zahl zurückgibt. Wird verwendet, um die Daten in einer JDBC-Tabelle beim parallelen Lesen aus JDBC-Tabellen in Partitionen zu unterteilen. Geben Sie „hashfield“ ODER „hashexpression“ an. Weitere Informationen finden Sie unter [Parallel aus JDBC-Tabellen lesen](run-jdbc-parallel-read-job.md).
+ `"hashpartitions"` (Optional) Eine positive Ganzzahl. Wird verwendet, um die Anzahl der parallelen Lesevorgänge der JDBC-Tabelle anzugeben, wenn parallel aus JDBC-Tabellen gelesen wird. Standard: 7. Weitere Informationen finden Sie unter [Parallel aus JDBC-Tabellen lesen](run-jdbc-parallel-read-job.md).
+ `"sampleQuery"`: (Optional) Eine benutzerdefinierte SQL-Abfrageanweisung. Wird verwendet, um eine Teilmenge von Informationen in einer Tabelle anzugeben, um ein Beispiel des Tabelleninhalts abzurufen. **Wenn es ohne Rücksicht auf Ihre Daten konfiguriert wird, kann es weniger effizient sein als DynamicFrame Methoden, was zu Timeouts oder Speichermangel führen kann.** Weitere Informationen finden Sie unter [sampleQuery verwenden](#aws-glue-programming-etl-jdbc-samplequery).
+ `"enablePartitioningForSampleQuery"`: (Optional) Ein boolescher Wert. Standard: falsch. Wird verwendet, um das parallele Lesen aus JDBC-Tabellen bei Angabe von `sampleQuery` zu ermöglichen. **Wenn auf true gesetzt, `sampleQuery` muss es mit „where“ oder „and“ enden, damit AWS Glue Partitionierungsbedingungen anhängt.** Weitere Informationen finden Sie unter [sampleQuery verwenden](#aws-glue-programming-etl-jdbc-samplequery).
+ `"sampleSize"`: (Optional) Eine positive Ganzzahl. Begrenzt die Anzahl der von der Beispielabfrage zurückgegebenen Zeilen. Funktioniert nur, wenn `enablePartitioningForSampleQuery` true ist. Wenn die Partitionierung nicht aktiviert ist, sollten Sie stattdessen `"limit x"` direkt in `sampleQuery` einfügen, um die Größe zu begrenzen. Weitere Informationen finden Sie unter [sampleQuery verwenden](#aws-glue-programming-etl-jdbc-samplequery).
## sampleQuery verwenden
Dieser Abschnitt erläutert die Verwendung von `sampleQuery`, `sampleSize` und `enablePartitioningForSampleQuery`.
`sampleQuery` kann ein effizienter Weg sein, um ein paar Zeilen Ihres Datensatzes abzufragen. In der Standardeinstellung wird die Abfrage von einem einzigen Ausführer ausgeführt. Wenn es ohne Rücksicht auf Ihre Daten konfiguriert wird, kann es weniger effizient sein als DynamicFrame Methoden, was zu Timeouts oder Fehlern aufgrund unzureichender Speicherkapazität führen kann. Das Ausführen von SQL in der zugrunde liegenden Datenbank als Teil Ihrer ETL-Pipeline ist im Allgemeinen nur aus Leistungsgründen erforderlich. Wenn Sie eine Vorschau einiger Zeilen Ihres Datensatzes anzeigen möchten, sollten Sie die Verwendung von [show](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show) in Betracht ziehen. Wenn Sie versuchen, Ihren Datensatz mit SQL zu transformieren, sollten Sie erwägen, eine SparkSQL-Transformation für Ihre Daten in einem DataFrame Formular [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) zu definieren.
Während Ihre Abfrage eine Vielzahl von Tabellen manipulieren kann, ist `dbtable` weiterhin erforderlich.
**Verwendung von sampleQuery zum Abrufen eines Beispiels Ihrer Tabelle**
Wenn Sie das Standardverhalten von SampleQuery verwenden, um eine Stichprobe Ihrer Daten abzurufen, erwartet AWS Glue keinen nennenswerten Durchsatz und führt Ihre Abfrage daher auf einem einzigen Executor aus. Um die von Ihnen bereitgestellten Daten zu begrenzen und keine Leistungsprobleme zu verursachen, empfehlen wir Ihnen, SQL mit einer `LIMIT`-Klausel bereitzustellen.
**Example Verwenden von sampleQuery ohne Partitionierung**
Das folgende Codebeispiel zeigt, wie `sampleQuery` ohne Partitionierung verwendet wird.
```
//A full sql query statement.
val query = "select name from $tableName where age > 0 limit 1"
val connectionOptions = JsonOptions(Map(
"url" -> url,
"dbtable" -> tableName,
"user" -> user,
"password" -> password,
"sampleQuery" -> query ))
val dyf = glueContext.getSource("mysql", connectionOptions)
.getDynamicFrame()
```
**Verwendung von sampleQuery für größere Datensätze**
Wenn Sie einen großen Datensatz lesen, müssen Sie möglicherweise die JDBC-Partitionierung aktivieren, um eine Tabelle parallel abzufragen. Weitere Informationen finden Sie unter [Parallel aus JDBC-Tabellen lesen](run-jdbc-parallel-read-job.md). Um `sampleQuery` mit JDBC-Partitionierung zu verwenden, legen Sie `enablePartitioningForSampleQuery` auf wahr fest. Um dieses Feature zu aktivieren, müssen Sie einige Änderungen an Ihrer `sampleQuery` vornehmen.
Wenn Sie die JDBC-Partitionierung mit verwenden`sampleQuery`, muss Ihre Abfrage mit „where“ oder „and“ enden, damit AWS Glue Partitionierungsbedingungen anhängen kann.
Wenn Sie die Ergebnisse Ihrer sampleQuery beim parallelen Lesen aus JDBC-Tabellen einschränken möchten, legen Sie den `"sampleSize"`-Parameter fest, anstatt eine `LIMIT`-Klausel anzugeben.
**Example Verwenden sampleQuery mit JDBC-Partitionierung**
Das folgende Codebeispiel zeigt, wie `sampleQuery` mit JDBC-Partitionierung verwendet wird.
```
//note that the query should end with "where" or "and" if use with JDBC partitioning.
val query = "select name from $tableName where age > 0 and"
//Enable JDBC partitioning by setting hashfield.
//to use sampleQuery with partitioning, set enablePartitioningForSampleQuery.
//use sampleSize to limit the size of returned data.
val connectionOptions = JsonOptions(Map(
"url" -> url,
"dbtable" -> tableName,
"user" -> user,
"password" -> password,
"hashfield" -> primaryKey,
"sampleQuery" -> query,
"enablePartitioningForSampleQuery" -> true,
"sampleSize" -> "1" ))
val dyf = glueContext.getSource("mysql", connectionOptions)
.getDynamicFrame()
```
**Hinweise und Einschränkungen:**
Beispielabfragen können nicht zusammen mit Auftragslesezeichen verwendet werden. Der Lesezeichenstatus wird ignoriert, wenn die Konfiguration für beide bereitgestellt wird.
## Benutzerdefinierten JDBC-Treiber verwenden
In den folgenden Codebeispielen wird gezeigt, wie JDBC-Datenbanken mit benutzerdefinierten JDBC-Treibern gelesen und geschrieben werden. Diese demonstrieren das Lesen aus einer Version eines Datenbankprodukts und das Schreiben in eine spätere Version desselben Produkts.
------
#### [ Python ]
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
from pyspark.sql.types import StructType, StructField, IntegerType, StringType
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# Construct JDBC connection options
connection_mysql5_options = {
"url": "jdbc:mysql://:3306/db",
"dbtable": "test",
"user": "admin",
"password": "pwd"}
connection_mysql8_options = {
"url": "jdbc:mysql://:3306/db",
"dbtable": "test",
"user": "admin",
"password": "pwd",
"customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar",
"customJdbcDriverClassName": "com.mysql.cj.jdbc.Driver"}
connection_oracle11_options = {
"url": "jdbc:oracle:thin:@//:1521/ORCL",
"dbtable": "test",
"user": "admin",
"password": "pwd"}
connection_oracle18_options = {
"url": "jdbc:oracle:thin:@//:1521/ORCL",
"dbtable": "test",
"user": "admin",
"password": "pwd",
"customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/ojdbc10.jar",
"customJdbcDriverClassName": "oracle.jdbc.OracleDriver"}
# Read from JDBC databases with custom driver
df_mysql8 = glueContext.create_dynamic_frame.from_options(connection_type="mysql",
connection_options=connection_mysql8_options)
# Read DynamicFrame from MySQL 5 and write to MySQL 8
df_mysql5 = glueContext.create_dynamic_frame.from_options(connection_type="mysql",
connection_options=connection_mysql5_options)
glueContext.write_from_options(frame_or_dfc=df_mysql5, connection_type="mysql",
connection_options=connection_mysql8_options)
# Read DynamicFrame from Oracle 11 and write to Oracle 18
df_oracle11 = glueContext.create_dynamic_frame.from_options(connection_type="oracle",
connection_options=connection_oracle11_options)
glueContext.write_from_options(frame_or_dfc=df_oracle11, connection_type="oracle",
connection_options=connection_oracle18_options)
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val MYSQL_5_URI: String = "jdbc:mysql://:3306/db"
val MYSQL_8_URI: String = "jdbc:mysql://:3306/db"
val ORACLE_11_URI: String = "jdbc:oracle:thin:@//:1521/ORCL"
val ORACLE_18_URI: String = "jdbc:oracle:thin:@//:1521/ORCL"
// Construct JDBC connection options
lazy val mysql5JsonOption = jsonOptions(MYSQL_5_URI)
lazy val mysql8JsonOption = customJDBCDriverJsonOptions(MYSQL_8_URI, "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar", "com.mysql.cj.jdbc.Driver")
lazy val oracle11JsonOption = jsonOptions(ORACLE_11_URI)
lazy val oracle18JsonOption = customJDBCDriverJsonOptions(ORACLE_18_URI, "s3://amzn-s3-demo-bucket/ojdbc10.jar", "oracle.jdbc.OracleDriver")
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Read from JDBC database with custom driver
val df_mysql8: DynamicFrame = glueContext.getSource("mysql", mysql8JsonOption).getDynamicFrame()
// Read DynamicFrame from MySQL 5 and write to MySQL 8
val df_mysql5: DynamicFrame = glueContext.getSource("mysql", mysql5JsonOption).getDynamicFrame()
glueContext.getSink("mysql", mysql8JsonOption).writeDynamicFrame(df_mysql5)
// Read DynamicFrame from Oracle 11 and write to Oracle 18
val df_oracle11: DynamicFrame = glueContext.getSource("oracle", oracle11JsonOption).getDynamicFrame()
glueContext.getSink("oracle", oracle18JsonOption).writeDynamicFrame(df_oracle11)
Job.commit()
}
private def jsonOptions(url: String): JsonOptions = {
new JsonOptions(
s"""{"url": "${url}",
|"dbtable":"test",
|"user": "admin",
|"password": "pwd"}""".stripMargin)
}
private def customJDBCDriverJsonOptions(url: String, customJdbcDriverS3Path: String, customJdbcDriverClassName: String): JsonOptions = {
new JsonOptions(
s"""{"url": "${url}",
|"dbtable":"test",
|"user": "admin",
|"password": "pwd",
|"customJdbcDriverS3Path": "${customJdbcDriverS3Path}",
|"customJdbcDriverClassName" : "${customJdbcDriverClassName}"}""".stripMargin)
}
}
```
------
# Parallel aus JDBC-Tabellen lesen
Sie können die Eigenschaften Ihrer JDBC-Tabelle so einstellen, dass AWS Glue Daten parallel lesen kann. Wenn Sie bestimmte Eigenschaften festlegen, weisen Sie AWS Glue an, parallele SQL-Abfragen gegen logische Partitionen Ihrer Daten auszuführen. Sie können die Partitionierung steuern, indem Sie ein Hash-Feld oder einen Hash-Ausdruck festlegen. Sie können auch die Anzahl der parallelen Lesezugriffe steuern, die für den Zugriff auf Ihre Daten verwendet werden.
Das parallele Lesen aus JDBC-Tabellen ist eine Optimierungsmethode, die die Leistung verbessern kann. Weitere Informationen darüber, wie ermittelt werden kann, wann diese Technik geeignet ist, finden Sie unter [Reduce the amount of data scan](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/parallelize-tasks.html) im Leitfaden *Best Practices for Performance Tuning AWS Glue for Apache Spark Jobs* auf AWS Prescriptive Guidance.
Um paralleles Lesen zu ermöglichen, können Sie Schlüssel-Wert-Paare im Parameterfeld Ihrer Tabellenstruktur setzen. Verwenden Sie eine JSON-Notation, um einen Wert für das Parameterfeld Ihrer Tabelle festzulegen. Weitere Informationen zum Bearbeiten der Eigenschaften einer Tabelle finden Sie unter [Anzeigen und Verwalten von Tabellendetails](tables-described.md#console-tables-details). Sie können auch parallele Lesevorgänge aktivieren, wenn Sie die ETL-Methoden (Extrahieren, Transformieren und Laden) `create_dynamic_frame_from_options` und `create_dynamic_frame_from_catalog` aufrufen. Weitere Informationen über das Festlegen der Optionen dieser Methoden finden Sie unter [from\$1options](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_options) und [from\$1catalog](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_catalog).
Sie können diese Methode für JDBC-Tabellen verwenden, d.h. für die meisten Tabellen, deren Grundlage ein JDBC-Datenspeicher ist. Diese Eigenschaften werden beim Lesen von Amazon-Redshift- und Amazon-S3-Tabellen ignoriert.
**hashfield**
Stellen Sie `hashfield` auf den Namen einer Spalte in der JDBC-Tabelle ein, die zur Aufteilung der Daten in Partitionen verwendet werden soll. Um optimale Ergebnisse zu erzielen, sollte diese Spalte eine gleichmäßige Verteilung der Werte aufweisen, um die Daten zwischen den Partitionen zu verteilen. Diese Spalte kann einen beliebigen Datentyp aufweisen. AWS Glue erzeugt nicht überlappende Abfragen, die parallel laufen, um die durch diese Spalte partitionierten Daten zu lesen. Wenn Ihre Daten beispielsweise gleichmäßig nach Monaten verteilt sind, können Sie die Spalte `month` verwenden, um die Daten für jeden Monat parallel zu lesen:
```
'hashfield': 'month'
```
AWS Glue erstellt eine Abfrage, um den Feldwert mit einer Partitionsnummer zu hashen, und führt die Abfrage für alle Partitionen parallel aus. Um Ihre eigene Abfrage zur Partitionierung einer gelesenen Tabelle zu verwenden, geben Sie `hashexpression` anstelle von `hashfield` an.
**hashexpression**
Setzen Sie `hashexpression` auf einen SQL-Ausdruck (entsprechend der Syntax der JDBC-Datenbankmaschine), der eine ganze Zahl zurückgibt. Ein einfacher Ausdruck ist der Name einer beliebigen numerischen Spalte in der Tabelle. AWS Glue erzeugt SQL-Abfragen zum parallelen Lesen der JDBC-Daten unter Verwendung von `hashexpression` in der `WHERE`-Klausel zur Partitionierung de Daten.
Verwenden Sie beispielsweise die numerische Spalte `customerID`, um Daten zu lesen, die nach Kundennummer partitioniert sind:
```
'hashexpression': 'customerID'
```
Zur AWS Glue Steuerung der Partitionierung, geben Sie `hashfield` anstelle von `hashexpression` an.
**hashpartitions**
Stellen Sie `hashpartitions` auf die Anzahl der parallelen Lesezugriffe der JDBC-Tabelle ein. Wenn diese Eigenschaft nicht festgelegt ist, wird der Standardwert 7 verwendet.
Stellen Sie beispielsweise die Anzahl der parallelen Lesezugriffe auf `5` ein, so dass AWS Glue Ihre Daten mit fünf Abfragen (oder weniger) liest:
```
'hashpartitions': '5'
```
# Einrichten von Amazon VPC für JDBC-Verbindungen zu Amazon-RDS-Datenspeichern von AWS Glue
Wenn Sie JDBC verwenden, um eine Verbindung zu Datenbanken in Amazon RDS herzustellen, müssen Sie zusätzliche Einstellungen vornehmen. Um die Kommunikation der AWS Glue-Komponenten mit Amazon RDS zu aktivieren, müssen Sie den Zugriff auf Ihre Amazon-RDS-Datenspeicher in Amazon VPC einrichten. Damit AWS Glue mit seinen Komponenten kommunizieren kann, geben Sie eine Sicherheitsgruppe mit einer selbstreferenzierenden eingehenden Regel für alle TCP-Ports an. Durch Erstellen einer selbstreferenzierenden Regel können Sie die Quelle auf die gleiche Sicherheitsgruppe in der VPC beschränken. Eine selbstreferenzierende Regel öffnet die VPC nicht für alle Netzwerke. Die Standardsicherheitsgruppe für Ihre VPC verfügt möglicherweise bereits über eine selbstreferenzierende eingehende Regel für den gesamten Datenverkehr (ALL Traffic).
**So richten Sie den Zugriff zwischen AWS Glue- und Amazon RDS-Datenspeichern ein**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Identifizieren Sie in der Amazon-RDS-Konsole die Sicherheitsgruppen, die zur Steuerung des Zugriffs auf Ihre Amazon-RDS-Datenbank verwendet werden.
Wählen Sie im linken Navigationsbereich **Datenbanken** und dann aus der Liste im Hauptbereich die Instance aus, zu der Sie eine Verbindung herstellen möchten.
Suchen Sie auf der Detailseite der Datenbank unter der Registerkarte **Konnektivität und Sicherheit** nach **VPC-Sicherheitsgruppen**.
1. Identifizieren Sie anhand Ihrer Netzwerkarchitektur, welche zugehörige Sicherheitsgruppe am besten geändert werden sollte, um den Zugriff für den AWS Glue-Dienst zu ermöglichen. Speichern Sie den Namen, *database-security-group* damit Sie später darauf zurückgreifen können. Wenn keine geeignete Sicherheitsgruppe vorhanden ist, befolgen Sie die Anweisungen unter [Ermöglichen des Zugriffs auf Ihre DB-Instance in der VPC durch Erstellen einer Sicherheitsgruppe](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SettingUp.html) in der Amazon-RDS-Dokumentation.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Identifizieren Sie in der Amazon VPC-Konsole, wie das Update *database-security-group* durchgeführt werden soll.
Wählen Sie im linken Navigationsbereich **Sicherheitsgruppen** aus und wählen Sie dann eine Gruppe *database-security-group* aus der Liste im Hauptbereich aus.
1. Identifizieren Sie die Sicherheitsgruppen-ID für*database-security-group*,*database-sg-id*. Bewahren Sie sie für die spätere Verwendung auf.
Suchen Sie auf der Seite mit den Sicherheitsgruppendetails nach der **Sicherheitsgruppen-ID**.
1. Ändern Sie die Regeln für eingehenden Datenverkehr und fügen Sie eine Regel hinzu*database-security-group*, die sich selbst referenziert, damit AWS Glue Komponenten miteinander kommunizieren können. **Fügen Sie insbesondere eine Regel hinzu oder stellen Sie sicher, dass es eine Regel gibt, bei der **Typ**`All TCP`, **Protokoll**`TCP`, **Portbereich** umfasst alle Ports und Quelle für steht.** *database-sg-id* Stellen Sie sicher, dass die Sicherheitsgruppe, die Sie für **Quelle** eingegeben haben, mit der Sicherheitsgruppe übereinstimmt, die Sie bearbeiten.
Wählen Sie auf der Seite mit den Sicherheitsgruppendetails die Option zum **Bearbeiten von Regeln für eingehenden Datenverkehr** aus.
Die eingehende Regel sollte etwa wie folgt aussehen:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/setup-vpc-for-glue-access.html)
1. Fügen Sie Regeln für ausgehenden Datenverkehr hinzu.
Wählen Sie auf der Seite mit den Sicherheitsgruppendetails die Option zum **Bearbeiten von Regeln für ausgehenden Datenverkehr** aus.
Wenn Ihre Sicherheitsgruppe den gesamten ausgehenden Datenverkehr zulässt, benötigen Sie keine separaten Regeln. Beispiel:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/setup-vpc-for-glue-access.html)
Wenn Ihre Netzwerkarchitektur so konzipiert ist, dass Sie den ausgehenden Datenverkehr einschränken können, erstellen Sie die folgenden Regeln für den ausgehenden Datenverkehr:
Erstellen Sie eine selbstreferenzierende Regel, in der **Typ** für`All TCP`, **Protokoll**`TCP`, **Portbereich** für alle Ports und **Ziel** für steht. *database-sg-id* Stellen Sie sicher, dass die Sicherheitsgruppe, die Sie als **Bestimmungsort** eingegeben haben, mit der Sicherheitsgruppe übereinstimmt, die Sie bearbeiten.
Wenn Sie einen Amazon-S3-VPC-Endpunkt verwenden, fügen Sie eine HTTPS-Regel hinzu, um den Datenverkehr vom VPC zu Amazon S3 zuzulassen. Erstellen Sie eine Regel, bei der **Typ**`HTTPS`, **Protokoll**`TCP`, **Portbereich** `443` und **Destination** die ID der verwalteten Präfixliste für den Amazon S3 S3-Gateway-Endpunkt ist*s3-prefix-list-id*. Weitere Informationen zu Präfixlisten und Amazon-S3-Gateway-Endpunkten finden Sie unter [Gateway-Endpunkte für Amazon S3](https://docs.aws.amazon.com//vpc/latest/privatelink/vpc-endpoints-s3.html) in der Amazon-VPC-Dokumentation.
Beispiel:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/setup-vpc-for-glue-access.html)
# MongoDB-Verbindungen
Sie können AWS Glue for Spark verwenden, um in MongoDB und MongoDB Atlas in AWS Glue 4.0 und späteren Versionen aus Tabellen zu lesen und in Tabellen zu schreiben. Sie können eine Verbindung zu MongoDB herstellen, indem Sie die Anmeldeinformationen für Benutzername und Passwort verwenden, die AWS Secrets Manager über eine AWS Glue-Verbindung gespeichert sind.
Weitere Informationen über MongoDB finden Sie in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/).
## Konfigurieren von MongoDB-Verbindungen
Um von AWS Glue aus eine Verbindung zu MongoDB herzustellen, benötigen Sie Ihre MongoDB-Anmeldeinformationen und*mongodbUser*. *mongodbPass*
Um von AWS Glue aus eine Verbindung zu MongoDB herzustellen, benötigen Sie möglicherweise einige Voraussetzungen:
+ Wenn sich Ihre MongoDB-Instance in einer Amazon VPC befindet, konfigurieren Sie Amazon VPC so, dass Ihr AWS Glue-Job mit der MongoDB-Instance kommunizieren kann, ohne dass der Datenverkehr das öffentliche Internet durchquert.
Identifizieren oder erstellen Sie in Amazon VPC eine **VPC**, ein **Subnetz** und eine **Sicherheitsgruppe**, die AWS Glue bei der Ausführung des Jobs verwendet. Darüber hinaus muss Amazon VPC so konfiguriert sein, dass der Netzwerkdatenverkehr zwischen Ihrer MongoDB-Instance und diesem Standort zugelassen wird. Abhängig von Ihrem Netzwerklayout kann dies Änderungen an den Sicherheitsgruppenregeln, dem Netzwerk ACLs, den NAT-Gateways und den Peering-Verbindungen erfordern.
Sie können dann mit der Konfiguration von AWS Glue für die Verwendung mit MongoDB fortfahren.
**Eine Verbindung zu MongoDB konfigurieren Sie wie folgt:**
1. Erstellen Sie optional ein Geheimnis mit Ihren MongoDB-Anmeldeinformationen. AWS Secrets Manager Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial, das in der AWS Secrets Manager Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) verfügbar ist. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `username` mit dem Wert. *mongodbUser*
Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `password` mit dem Wert. *mongodbPass*
1. Stellen Sie in der AWS Glue-Konsole eine Verbindung her, indem Sie den Schritten unter folgen[AWS Glue Verbindung hinzufügen](console-connections.md). Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für die future Verwendung in AWS Glue bei. *connectionName*
+ Wählen Sie als **Verbindungstyp** die Option **MongoDB** oder **MongoDB Atlas** aus.
+ Geben Sie als **MongoDB-URL** oder **MongoDB-Atlas-URL** den Hostnamen Ihrer MongoDB-Instance an.
Eine MongoDB-URL wird im Format `mongodb://mongoHost:mongoPort/mongoDBname` bereitgestellt.
Eine MongoDB-Atlas-URL wird im Format `mongodb+srv://mongoHost/mongoDBname` bereitgestellt.
+ Wenn Sie ein Secrets Manager Manager-Geheimnis erstellen möchten, wählen Sie den **Typ AWS Secrets Manager Credential**.
Geben Sie dann in **AWS Secret Folgendes** ein*secretName*.
+ Wenn Sie sich dafür entscheiden, **Benutzername und Passwort** anzugeben, geben Sie *mongodbUser* und ein*mongodbPass*.
1. In den folgenden Situationen ist möglicherweise eine zusätzliche Konfiguration erforderlich:
+
Für MongoDB-Instances, die AWS in einer Amazon VPC gehostet werden
+ Sie müssen Amazon VPC-Verbindungsinformationen für die AWS Glue-Verbindung bereitstellen, die Ihre MongoDB-Sicherheitsanmeldedaten definiert. Wenn Sie Ihre Verbindung erstellen oder aktualisieren, legen Sie **VPC**, **Subnetz** und **Sicherheitsgruppen** in den **Netzwerkoptionen** fest.
Nachdem Sie eine AWS Glue MongoDB-Verbindung erstellt haben, müssen Sie die folgenden Aktionen ausführen, bevor Sie Ihre Verbindungsmethode aufrufen:
+ Wenn Sie sich dafür entschieden haben, ein Secrets Manager Manager-Geheimnis zu erstellen, gewähren Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle *secretName* Leserechte.
+ Stellen *connectionName* Sie in Ihrer AWS Glue-Job-Konfiguration eine **zusätzliche Netzwerkverbindung** bereit.
Um Ihre AWS Glue MongoDB-Verbindung in AWS Glue for Spark zu verwenden, geben Sie die `connectionName` Option in Ihrem Verbindungsmethodenaufruf an. Alternativ können Sie den Schritten unter folgen, [Arbeiten mit MongoDB-Verbindungen in ETL-Aufträgen](integrate-with-mongo-db.md) um die Verbindung in Verbindung mit dem AWS Glue-Datenkatalog zu verwenden.
## Mit einer AWS Glue-Verbindung aus MongoDB lesen
**Voraussetzungen:**
+ Eine MongoDB-Sammlung, aus der Sie lesen möchten. Sie benötigen Identifikationsinformationen für die Sammlung.
Eine MongoDB-Sammlung wird durch einen Datenbanknamen und einen Sammlungsnamen identifiziert,*mongodbName*,*mongodbCollection*.
+ Eine AWS Glue MongoDB-Verbindung, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Gehen Sie wie im vorherigen Verfahren beschrieben vor, *um eine Verbindung zu MongoDB zu konfigurieren*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
mongodb_read = glueContext.create_dynamic_frame.from_options(
connection_type="mongodb",
connection_options={
"connectionName": "connectionName",
"database": "mongodbName",
"collection": "mongodbCollection",
"partitioner": "com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id",
"disableUpdateUri": "false",
}
)
```
## Schreiben in MongoDB-Tabellen
In diesem Beispiel werden Informationen aus einer vorhandenen DynamicFrame Datenbank in MongoDB geschrieben. *dynamicFrame*
**Voraussetzungen:**
+ Eine MongoDB-Sammlung, in der Sie schreiben möchten. Sie benötigen Identifikationsinformationen für die Sammlung.
Eine MongoDB-Sammlung wird durch einen Datenbanknamen und einen Sammlungsnamen identifiziert,*mongodbName*,*mongodbCollection*.
+ Eine AWS Glue MongoDB-Verbindung, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Gehen Sie wie im vorherigen Verfahren beschrieben vor, *um eine Verbindung zu MongoDB zu konfigurieren*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="mongodb",
connection_options={
"connectionName": "connectionName",
"database": "mongodbName",
"collection": "mongodbCollection",
"disableUpdateUri": "false",
"retryWrites": "false",
},
)
```
## Lesen und Schreiben von Tabellen in MongoDB-Tabellen
In diesem Beispiel werden Informationen aus einer vorhandenen DynamicFrame Datenbank in MongoDB geschrieben. *dynamicFrame*
**Voraussetzungen:**
+ Eine MongoDB-Sammlung, aus der Sie lesen möchten. Sie benötigen Identifikationsinformationen für die Sammlung.
Eine MongoDB-Sammlung, in der Sie schreiben möchten. Sie benötigen Identifikationsinformationen für die Sammlung.
Eine MongoDB-Sammlung wird durch einen Datenbanknamen und einen Sammlungsnamen identifiziert,*mongodbName*,*mongodbCollection*.
+ MongoDB-Authentifizierungsinformationen und*mongodbUser*. *mongodbPassword*
Beispiel:
------
#### [ Python ]
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
output_path = "s3://some_bucket/output/" + str(time.time()) + "/"
mongo_uri = "mongodb://:27017"
mongo_ssl_uri = "mongodb://:27017"
write_uri = "mongodb://:27017"
read_mongo_options = {
"uri": mongo_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"username": "mongodbUsername",
"password": "mongodbPassword",
"partitioner": "MongoSamplePartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id"}
ssl_mongo_options = {
"uri": mongo_ssl_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"ssl": "true",
"ssl.domain_match": "false"
}
write_mongo_options = {
"uri": write_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"username": "mongodbUsername",
"password": "mongodbPassword",
}
# Get DynamicFrame from MongoDB
dynamic_frame = glueContext.create_dynamic_frame.from_options(connection_type="mongodb",
connection_options=read_mongo_options)
# Write DynamicFrame to MongoDB
glueContext.write_dynamic_frame.from_options(dynamicFrame, connection_type="mongodb", connection_options=write_mongo_options)
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val DEFAULT_URI: String = "mongodb://:27017"
val WRITE_URI: String = "mongodb://:27017"
lazy val defaultJsonOption = jsonOptions(DEFAULT_URI)
lazy val writeJsonOption = jsonOptions(WRITE_URI)
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Get DynamicFrame from MongoDB
val dynamicFrame: DynamicFrame = glueContext.getSource("mongodb", defaultJsonOption).getDynamicFrame()
// Write DynamicFrame to MongoDB
glueContext.getSink("mongodb", writeJsonOption).writeDynamicFrame(dynamicFrame)
Job.commit()
}
private def jsonOptions(uri: String): JsonOptions = {
new JsonOptions(
s"""{"uri": "${uri}",
|"database":"mongodbName",
|"collection":"mongodbCollection",
|"username": "mongodbUsername",
|"password": "mongodbPassword",
|"ssl":"true",
|"ssl.domain_match":"false",
|"partitioner": "MongoSamplePartitioner",
|"partitionerOptions.partitionSizeMB": "10",
|"partitionerOptions.partitionKey": "_id"}""".stripMargin)
}
}
```
------
## Referenz zur MongoDB-Verbindungsoption
Bezeichnet eine Verbindung mit MongoDB. Die Anschlussmöglichkeiten bei einer Quellverbindung und eine Senkenverbindung unterscheiden sich.
Diese Verbindungseigenschaften werden von Quell- und Senkenverbindungen gemeinsam genutzt:
+ `connectionName` – Wird zum Lesen/Schreiben verwendet. Der Name einer AWS Glue MongoDB-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkinformationen für Ihre Verbindungsmethode bereitstellt. Wenn eine AWS Glue-Verbindung wie im vorherigen Abschnitt beschrieben konfiguriert ist[Konfigurieren von MongoDB-Verbindungen](#aws-glue-programming-etl-connect-mongodb-configure), ersetzt das `connectionName` Bereitstellen der Verbindungsoptionen die Notwendigkeit`"uri"`, die `"username"` und `"password"` -Verbindungsoptionen bereitzustellen.
+ `"uri"`: (Erforderlich) Der als `mongodb://:` formatierte MongoDB-Host, von dem gelesen werden soll. Wird in AWS Glue-Versionen vor AWS Glue 4.0 verwendet.
+ `"connection.uri"`: (Erforderlich) Der als `mongodb://:` formatierte MongoDB-Host, von dem gelesen werden soll. Wird in AWS Glue 4.0 und späteren Versionen verwendet.
+ `"username"`: (Erforderlich) Der MongoDB-Benutzername.
+ `"password"`: (Erforderlich) Das MongoDB-Passwort.
+ `"database"`: (Erforderlich) Die MongoDB-Datenbank, aus der gelesen werden soll. Diese Option kann auch in `additional_options` beim Aufruf von `glue_context.create_dynamic_frame_from_catalog` in Ihrem Auftragsskript übergeben werden.
+ `"collection"`: (Erforderlich) Die MongoDB-Sammlung, aus der gelesen werden soll. Diese Option kann auch in `additional_options` beim Aufruf von `glue_context.create_dynamic_frame_from_catalog` in Ihrem Auftragsskript übergeben werden.
### „connectionType“: „mongodb“ als Quelle
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "mongodb"` als Quelle:
+ `"ssl"`: (Optional) Wenn `true`, wird eine SSL-Verbindung initiiert. Der Standardwert ist `false`.
+ `"ssl.domain_match"`: (Optional) Wenn `true` und wenn `ssl` „`true`“ ist, wird die Prüfung der Domainübereinstimmung durchgeführt. Der Standardwert ist `true`.
+ `"batchSize"`: (Optional): Die Anzahl der pro Batch zurückzugebenden Dokumente, die innerhalb des Cursors interner Batches verwendet werden.
+ `"partitioner"`: (Optional): Der Klassenname des Partitionierers zum Lesen von Eingabedaten aus MongoDB. Der Konnektor stellt die folgenden Partitionierer bereit:
+ `MongoDefaultPartitioner`(Standard) (In AWS Glue 4.0 nicht unterstützt)
+ `MongoSamplePartitioner`(Erfordert MongoDB 3.2 oder höher) (Wird in AWS Glue 4.0 nicht unterstützt)
+ `MongoShardedPartitioner`(In AWS Glue 4.0 nicht unterstützt)
+ `MongoSplitVectorPartitioner`(In AWS Glue 4.0 nicht unterstützt)
+ `MongoPaginateByCountPartitioner`(In AWS Glue 4.0 nicht unterstützt)
+ `MongoPaginateBySizePartitioner`(In AWS Glue 4.0 nicht unterstützt)
+ `com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner`
+ `com.mongodb.spark.sql.connector.read.partitioner.ShardedPartitioner`
+ `com.mongodb.spark.sql.connector.read.partitioner.PaginateIntoPartitionsPartitioner`
+ `"partitionerOptions"` (Optional): Optionen für den angegebenen Partitionierer. Die folgenden Optionen werden für jeden Partitionierer unterstützt:
+ `MongoSamplePartitioner`: `partitionKey`, `partitionSizeMB`, `samplesPerPartition`
+ `MongoShardedPartitioner`: `shardkey`
+ `MongoSplitVectorPartitioner`: `partitionKey`, `partitionSizeMB`
+ `MongoPaginateByCountPartitioner`: `partitionKey`, `numberOfPartitions`
+ `MongoPaginateBySizePartitioner`: `partitionKey`, `partitionSizeMB`
Weitere Informationen zu diesen Optionen finden Sie unter [Partitioner-Konfiguration](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) in der MongoDB-Dokumentation.
### „connectionType“: „mongodb“ als Sink
Verwenden Sie die folgenden Verbindungsoptionen mit `"connectionType": "mongodb"` als Senke:
+ `"ssl"`: (Optional) Wenn `true`, wird eine SSL-Verbindung initiiert. Der Standardwert ist `false`.
+ `"ssl.domain_match"`: (Optional) Wenn `true` und wenn `ssl` „`true`“ ist, wird die Prüfung der Domainübereinstimmung durchgeführt. Der Standardwert ist `true`.
+ `"extendedBsonTypes"`: (Optional) Wenn `true`, werden beim Schreiben von Daten in MongoDB erweiterte BSON-Typen erlaubt. Der Standardwert ist `true`.
+ `"replaceDocument"`: (Optional) Wenn `true`, wird das gesamte Dokument beim Speichern von Datasets, die ein `_id`-Feld enthalten, ersetzt. Wenn `false`, werden nur Felder im Dokument aktualisiert, die mit den Feldern im Dataset übereinstimmen. Der Standardwert ist `true`.
+ `"maxBatchSize"`: (Optional): Die maximale Batchgröße für Massenvorgänge bei der Datenspeicherung. Der Standardwert ist 512.
+ `"retryWrites"`: (Optional): Automatische Wiederholung bestimmter Schreibvorgänge ein einziges Mal, wenn AWS Glue auf einen Netzwerkfehler stößt.
# SAP-HANA-Verbindungen
Sie können AWS Glue for Spark verwenden, um in SAP HANA in AWS Glue 4.0 und späteren Versionen aus Tabellen zu lesen und in Tabellen zu schreiben. Sie können definieren, was mit einer SQL-Abfrage aus SAP-HANA gelesen werden soll. Sie stellen mithilfe von JDBC-Anmeldeinformationen, die AWS Secrets Manager über eine AWS Glue SAP HANA-Verbindung gespeichert sind, eine Verbindung zu SAP HANA her.
Weitere Informationen zu SAP HANA JDBC finden Sie in der [SAP-HANA-Dokumentation](https://help.sap.com/docs/SAP_HANA_PLATFORM/0eec0d68141541d1b07893a39944924e/ff15928cf5594d78b841fbbe649f04b4.html).
## Konfigurieren von SAP-HANA-Verbindungen
Um von AWS Glue aus eine Verbindung zu SAP HANA herzustellen, müssen Sie Ihre SAP HANA-Anmeldeinformationen erstellen und in einem AWS Secrets Manager Secret speichern und dieses Secret dann mit einer SAP HANA AWS Glue-Verbindung verknüpfen. Sie müssen die Netzwerkkonnektivität zwischen Ihrem SAP HANA-Service und AWS Glue konfigurieren.
Voraussetzungen für eine Verbindung mit SAP HANA:
+ Wenn sich Ihr SAP HANA-Service in einer Amazon VPC befindet, konfigurieren Sie Amazon VPC so, dass Ihr AWS Glue-Job mit dem SAP HANA-Service kommunizieren kann, ohne dass der Datenverkehr das öffentliche Internet durchquert.
Identifizieren oder erstellen Sie in Amazon VPC eine **VPC**, ein **Subnetz** und eine **Sicherheitsgruppe**, die AWS Glue bei der Ausführung des Jobs verwendet. Darüber hinaus muss Amazon VPC so konfiguriert sein, dass der Netzwerkdatenverkehr zwischen Ihrem SAP-HANA-Endpunkt und diesem Standort zugelassen wird. Ihr Auftrag muss eine TCP-Verbindung mit Ihrem SAP-HANA-JDBC-Port herstellen. Weitere Informationen zu SAP-HANA-Ports finden Sie in der [Dokumentation von SAP HANA](https://help.sap.com/docs/HANA_SMART_DATA_INTEGRATION/7952ef28a6914997abc01745fef1b607/88e2e8bded9e4041ad3ad87dc46c7b55.html?locale=en-US). Abhängig von Ihrem Netzwerklayout kann dies Änderungen an den Sicherheitsgruppenregeln, dem Netzwerk ACLs, den NAT-Gateways und den Peering-Verbindungen erfordern.
+ Es gibt keine zusätzlichen Voraussetzungen, wenn Ihr SAP-HANA-Endpunkt über das Internet zugänglich ist.
**Konfigurieren Sie eine Verbindung zu SAP HANA wie folgt:**
1. Erstellen Sie AWS Secrets Manager unter Verwendung Ihrer SAP HANA-Anmeldeinformationen ein Geheimnis. Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial, das in der AWS Secrets Manager Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) verfügbar ist. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `username/USERNAME` mit dem Wert. *saphanaUsername*
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `password/PASSWORD` mit dem Wert. *saphanaPassword*
1. Stellen Sie in der AWS Glue-Konsole eine Verbindung her, indem Sie den Schritten unter folgen[AWS Glue Verbindung hinzufügen](console-connections.md). Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für die future Verwendung in AWS Glue bei. *connectionName*
+ Wählen Sie als **Verbindungstyp** SAP HANA aus.
+ Wenn Sie die **SAP-HANA-URL** angeben, geben Sie die URL für Ihre Instance an.
SAP HANA JDBC URLs haben das folgende Format `jdbc:sap://saphanaHostname:saphanaPort/?databaseName=saphanaDBname,ParameterName=ParameterValue`
AWS Glue benötigt die folgenden JDBC-URL-Parameter:
+ `databaseName` – Eine Standarddatenbank in SAP HANA, mit der eine Verbindung hergestellt werden kann.
+ Geben Sie bei der Auswahl eines **AWS Geheimnisses Folgendes** an. *secretName*
Nachdem Sie eine AWS Glue SAP HANA-Verbindung erstellt haben, müssen Sie die folgenden Schritte ausführen, bevor Sie Ihren AWS Glue-Job ausführen:
+ Erteilen Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle *secretName* Leserechte.
+ Stellen *connectionName* Sie in Ihrer AWS Glue-Job-Konfiguration eine **zusätzliche Netzwerkverbindung** bereit.
## Lesen aus SAP-HANA-Tabellen
**Voraussetzungen:**
+ Eine SAP-HANA-Tabelle, aus der gelesen werden soll. Sie benötigen Identifikationsinformationen für die Tabelle.
Eine Tabelle kann mit einem SAP-HANA-Tabellennamen und -Schemanamen im folgenden Format angegeben werden: `schemaName.tableName`. Der Schemaname und das Trennzeichen „.“ sind nicht erforderlich, wenn sich die Tabelle im Standardschema „public“ befindet. Nennen Sie das*tableIdentifier*. Beachten Sie, dass die Datenbank als JDBC-URL-Parameter in `connectionName` bereitgestellt wird.
+ Eine AWS Glue SAP HANA-Verbindung, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Gehen Sie wie im vorherigen Verfahren beschrieben vor, *um eine Verbindung zu SAP HANA zu konfigurieren*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
saphana_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="saphana",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier",
}
)
```
Sie können auch eine SELECT-SQL-Abfrage angeben, um die an Ihre zurückgegebenen Ergebnisse zu filtern DynamicFrame. Sie müssen `query` konfigurieren.
Beispiel:
```
saphana_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="saphana",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Schreiben in SAP-HANA-Tabellen
In diesem Beispiel werden Informationen aus einer vorhandenen Datei DynamicFrame *dynamicFrame* in SAP HANA geschrieben. Wenn die Tabelle bereits Informationen enthält, gibt AWS Glue einen Fehler aus.
**Voraussetzungen:**
+ Eine SAP-HANA-Tabelle, in die geschrieben werden soll.
Eine Tabelle kann mit einem SAP-HANA-Tabellennamen und -Schemanamen im folgenden Format angegeben werden: `schemaName.tableName`. Der Schemaname und das Trennzeichen „.“ sind nicht erforderlich, wenn sich die Tabelle im Standardschema „public“ befindet. Nenn das*tableIdentifier*. Beachten Sie, dass die Datenbank als JDBC-URL-Parameter in `connectionName` bereitgestellt wird.
+ SAP-HANA-Authentifizierungsinformationen. Gehen Sie wie im vorherigen Verfahren beschrieben vor, *um eine Verbindung zu SAP HANA zu konfigurieren*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
options = {
"connectionName": "connectionName",
"dbtable": 'tableIdentifier'
}
saphana_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="saphana",
connection_options=options
)
```
## Referenz zur SAP-HANA-Verbindungsoption
+ `connectionName` – Erforderlich. Wird für Lesen/Schreiben verwendet. Der Name einer AWS Glue SAP HANA-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkinformationen für Ihre Verbindungsmethode bereitstellt.
+ `databaseName` – Wird zum Lesen/Schreiben verwendet. Gültige Werte: Namen von Datenbanken in SAP HANA. Name der Datenbank, mit der eine Verbindung hergestellt werden soll.
+ `dbtable` – Zum Schreiben erforderlich, zum Lesen erforderlich, sofern `query` nicht angegeben ist. Wird für Lesen/Schreiben verwendet. Gültige Werte: Inhalt einer SQL-FROM-Klausel in SAP HANA. Identifiziert eine Tabelle in SAP HANA, zu der eine Verbindung hergestellt werden soll. Sie können auch anderes SQL als einen Tabellennamen angeben, z. B. eine Unterabfrage. Weitere Informationen finden Sie unter [From clause](https://help.sap.com/docs/SAP_HANA_PLATFORM/4fe29514fd584807ac9f2a04f6754767/20fcf24075191014a89e9dc7b8408b26.html#loio20fcf24075191014a89e9dc7b8408b26__from_clause) in der Dokumentation von SAP HANA.
+ `query` – Wird zum Lesen verwendet. Eine SQL-SELECT-Abfrage von SAP HANA, die definiert, was beim Lesen aus SAP HANA abgerufen werden soll.
# Snowflake-Verbindungen
In AWS Glue 4.0 und späteren Versionen können Sie Glue for Spark verwenden, um aus Tabellen in Snowflake zu lesen und in AWS Tabellen zu schreiben. Sie können aus Snowflake mit einer SQL-Abfrage lesen. Sie können mit einem Benutzer und einem Passwort eine Verbindung zu Snowflake herstellen. Sie können auf Snowflake-Anmeldeinformationen verweisen, die im AWS Secrets Manager AWS Glue-Datenkatalog gespeichert sind. Data Catalog Snowflake-Anmeldeinformationen für AWS Glue for Spark werden getrennt von Data Catalog Snowflake-Anmeldeinformationen für Crawler gespeichert. Sie müssen einen `SNOWFLAKE`-Verbindungstyp auswählen und keinen `JDBC`-Verbindungstyp, der für die Verbindung mit Snowflake konfiguriert ist.
Weitere Informationen zu Snowflake finden Sie auf der [Snowflake-Website](https://www.snowflake.com/). Weitere Informationen zu Snowflake finden Sie unter [Snowflake Data Warehouse auf](https://aws.amazon.com/financial-services/partner-solutions/snowflake/) Amazon Web Services. AWS
## Konfiguration von Snowflake-Verbindungen
Es gibt keine AWS Voraussetzungen für die Verbindung zu Snowflake-Datenbanken, die über das Internet verfügbar sind.
Optional können Sie die folgende Konfiguration durchführen, um Ihre Verbindungsdaten mit AWS Glue zu verwalten.
**Um Ihre Verbindungsdaten mit AWS Glue zu verwalten**
1. Generieren Sie in Snowflake einen Benutzer *snowflakeUser* und ein Passwort. *snowflakePassword*
1. Erstellen Sie in AWS Secrets Manager ein Geheimnis mit Ihren Snowflake-Anmeldeinformationen. Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial, das in der AWS Secrets Manager Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html#create_secret_cli) verfügbar ist. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für *snowflakeUser* mit dem Schlüssel. `USERNAME`
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für *snowflakePassword* mit dem Schlüssel. `PASSWORD`
+ Bei der Auswahl von **Schlüssel/Wert-Paaren** können Sie Ihrem Snowflake-Warehouse den Schlüssel `sfWarehouse` bereitstellen.
+ Bei der Auswahl von **Schlüssel/Wert-Paaren** können Sie zusätzliche Snowflake-Verbindungseigenschaften angeben, indem Sie die entsprechenden Spark-Eigenschaftsnamen als Schlüssel verwenden. Folgende sind unterstützte Eigenschaften:
+ `sfDatabase`: Name der Snowflake-Datenbank
+ `sfSchema`: Name des Snowflake-Schemas
+ `sfRole`: Name der Snowflake-Rolle
+ `pem_private_key`: privater Schlüssel zur Schlüsselpaar-Authentifizierung
1. Erstellen AWS Sie im Glue-Datenkatalog eine Verbindung, indem Sie **Verbindungen** und dann **Verbindung erstellen** wählen. Befolgen Sie die Schritte im Verbindungsassistenten, um den Vorgang abzuschließen:
+ Wählen Sie bei der Auswahl einer **Datenquelle** die Option „Snowflake“ und dann **Weiter** aus.
+ Geben Sie die Verbindungsdetails wie Host und Port ein. Geben Sie bei der Auswahl der **Snowflake-URL** des Hosts die URL der Snowflake-Instance an. Die URL verwendet einen Hostnamen im Format `account_identifier.snowflakecomputing.com`. Das URL-Format kann jedoch je nach Ihrem Snowflake-Kontotyp variieren (z. B. Azure oder von Snowflake gehostet). AWS
+ Wählen Sie bei der Auswahl der IAM-Servicerolle eine Option aus dem Dropdown-Menü. Dies ist die IAM-Rolle aus Ihrem Konto, die für den Zugriff auf AWS Secrets Manager und die Zuweisung von IP-Adressen verwendet wird, wenn VPC angegeben ist.
+ Geben Sie bei der Auswahl eines **AWS Geheimnisses Folgendes** an. *secretName*
1. Legen Sie im nächsten Schritt des Assistenten die Eigenschaften für Ihre Snowflake-Verbindung fest.
1. Überprüfen Sie im letzten Schritt des Assistenten Ihre Einstellungen und schließen Sie dann den Vorgang ab, um Ihre Verbindung herzustellen.
In den folgenden Situationen benötigen Sie möglicherweise Folgendes:
+
Für Snowflake, gehostet auf einer AWS Amazon VPC
+ Sie benötigen eine entsprechende Amazon-VPC-Konfiguration für Snowflake. Weitere Informationen zur Konfiguration Ihrer Amazon VPC finden Sie unter [AWS PrivateLink & Snowflake](https://docs.snowflake.com/en/user-guide/admin-security-privatelink) in der Snowflake-Dokumentation.
+ Sie benötigen eine entsprechende Amazon VPC-Konfiguration für AWS Glue. [Konfigurieren von Schnittstellen-VPC-Endpunkten (AWS PrivateLink) für AWS Glue (AWS PrivateLink)](vpc-interface-endpoints.md).
+ Sie müssen eine AWS Glue Data Catalog-Verbindung erstellen, die Amazon VPC-Verbindungsinformationen bereitstellt (zusätzlich zur ID eines AWS Secrets Manager Secrets, das Ihre Snowflake-Sicherheitsanmeldedaten definiert). Ihre URL ändert sich bei der Verwendung AWS PrivateLink, wie in der Snowflake-Dokumentation beschrieben, die in einem vorherigen Artikel verlinkt wurde.
+ Sie müssen in Ihrer Auftragskonfiguration die Verbindung zum Datenkatalog als **zusätzliche Netzwerkverbindung** einschließen.
## Lesen aus Snowflake-Tabellen
**Voraussetzungen:** Eine Snowflake-Tabelle, aus der Sie gerne lesen möchten. Sie benötigen den Namen der Snowflake-Tabelle,. *tableName* Sie benötigen Ihre Snowflake-URL*snowflakeUrl*, Ihren Benutzernamen und Ihr Passwort. *snowflakeUser* *snowflakePassword* Wenn Ihr Snowflake-Benutzer keinen Standard-Namespace festgelegt hat, benötigen Sie den Snowflake-Datenbanknamen und den Schemanamen. *databaseName* *schemaName* Wenn Ihr Snowflake-Benutzer kein Standard-Warehouse-Set hat, benötigen Sie außerdem einen Warehouse-Namen. *warehouseName*
Beispiel:
**Zusätzliche Voraussetzungen:** Führen Sie die Schritte *zur Verwaltung Ihrer Verbindungsdaten mit AWS Glue* aus, um sie zu konfigurieren*snowflakeUrl*, *snowflakeUsername* und*snowflakePassword*. Weitere Informationen zu diesen Schritten finden Sie im vorherigen Abschnitt unter [Konfiguration von Snowflake-Verbindungen](#aws-glue-programming-etl-connect-snowflake-configure). Um auszuwählen, mit welcher **zusätzlichen Netzwerkverbindung** eine Verbindung hergestellt werden soll, verwenden wir den `connectionName`-Parameter.
```
snowflake_read = glueContext.create_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
}
)
```
Darüber hinaus können Sie die Parameter `autopushdown` und `query` verwenden, um einen Teil einer Snowflake-Tabelle zu lesen. Dies kann wesentlich effizienter sein als das Filtern Ihrer Ergebnisse, nachdem diese in Spark geladen wurden. Stellen Sie sich ein Beispiel vor, bei dem alle Verkäufe in derselben Tabelle gespeichert sind, Sie jedoch nur die Verkäufe eines bestimmten Geschäfts an Feiertagen analysieren müssen. Wenn diese Informationen in der Tabelle gespeichert sind, können Sie mithilfe des Prädikat-Pushdowns die Ergebnisse wie folgt abrufen:
```
snowflake_node = glueContext.create_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"autopushdown": "on",
"query": "select * from sales where store='1' and IsHoliday='TRUE'",
"connectionName": "snowflake-glue-conn",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
}
)
```
## Schreiben in Snowflake-Tabellen
**Voraussetzungen:** Eine Snowflake-Datenbank, in die Sie schreiben möchten. Sie benötigen einen aktuellen oder gewünschten Tabellennamen,*tableName*. Sie benötigen Ihre Snowflake-URL*snowflakeUrl*, Ihren Benutzernamen *snowflakeUser* und Ihr Passwort. *snowflakePassword* Wenn Ihr Snowflake-Benutzer keinen Standard-Namespace festgelegt hat, benötigen Sie den Snowflake-Datenbanknamen und den Schemanamen. *databaseName* *schemaName* Wenn Ihr Snowflake-Benutzer kein Standard-Warehouse-Set hat, benötigen Sie außerdem einen Warehouse-Namen. *warehouseName*
Beispiel:
**Zusätzliche Voraussetzungen:** Führen Sie die Schritte *zur Verwaltung Ihrer Verbindungsdaten mit AWS Glue* aus, um sie zu konfigurieren*snowflakeUrl*, *snowflakeUsername* und*snowflakePassword*. Weitere Informationen zu diesen Schritten finden Sie im vorherigen Abschnitt unter [Konfiguration von Snowflake-Verbindungen](#aws-glue-programming-etl-connect-snowflake-configure). Um auszuwählen, mit welcher **zusätzlichen Netzwerkverbindung** eine Verbindung hergestellt werden soll, verwenden wir den `connectionName`-Parameter.
```
glueContext.write_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
},
)
```
## Referenz zur Snowflake-Verbindungsoption
Der Snowflake-Verbindungstyp akzeptiert die folgenden Verbindungsoptionen:
Sie können einige der Parameter in diesem Abschnitt über eine Data-Catalog-Verbindung (`sfUrl`, `sfUser`, `sfPassword`) abrufen. In diesem Fall müssen Sie sie nicht angeben. Sie können dies tun, indem Sie den Parameter `connectionName` angeben.
Mithilfe des `secretId` Parameters können Sie Verbindungsparameter aus AWS Secrets Manager Geheimnissen abrufen. Bei Verwendung von Secrets Manager können die folgenden Spark-Eigenschaften automatisch abgerufen werden, sofern sie im Geheimnis enthalten sind:
+ `sfUser` (mit dem Schlüssel `USERNAME` oder`sfUser`)
+ `sfPassword` (mit dem Schlüssel `PASSWORD` oder`sfPassword`)
+ `sfWarehouse` (mit dem Schlüssel `sfWarehouse`)
+ `sfDatabase` (mit dem Schlüssel `sfDatabase`)
+ `sfSchema` (mit dem Schlüssel `sfSchema`)
+ `sfRole` (mit dem Schlüssel `sfRole`)
+ `pem_private_key` (mit dem Schlüssel `pem_private_key`)
**Prioritätsreihenfolge:** Wenn dieselbe Eigenschaft an mehreren Stellen angegeben ist, verwendet AWS Glue die folgende Prioritätsreihenfolge (vom höchsten zum niedrigsten):
1. Explizit angegebene Verbindungsoptionen in Ihrem Auftragscode
1. Datenkatalog-Verbindungseigenschaften
1. AWS Secrets Manager geheime Werte (wenn `secretId` angegeben)
1. Snowflake-Benutzerstandardwerte
Die folgenden Parameter werden im Allgemeinen beim Herstellen einer Verbindung mit Snowflake verwendet.
+ `sfDatabase` – Erforderlich, wenn in Snowflake kein Benutzerstandard festgelegt ist. Wird für Lesen/Schreiben verwendet. Die Datenbank, die nach dem Herstellen der Verbindung für die Sitzung verwendet werden soll.
+ `sfSchema` – Erforderlich, wenn in Snowflake kein Benutzerstandard festgelegt ist. Wird für Lesen/Schreiben verwendet. Das Schema, das für die Sitzung nach dem Herstellen der Verbindung verwendet werden soll.
+ `sfWarehouse` – Erforderlich, wenn in Snowflake kein Benutzerstandard festgelegt ist. Wird für Lesen/Schreiben verwendet. Das standardmäßige virtuelle Warehouse, das für die Sitzung nach dem Herstellen der Verbindung verwendet wird.
+ `sfRole` – Erforderlich, wenn in Snowflake kein Benutzerstandard festgelegt ist. Wird für Lesen/Schreiben verwendet. Die Standardsicherheitsrolle, die nach dem Herstellen der Verbindung für die Sitzung verwendet wird.
+ `sfUrl` – (Erforderlich) Wird zum Lesen/Schreiben verwendet. Gibt den Hostnamen für Ihr Konto im folgenden Format an: `account_identifier.snowflakecomputing.com`. Weitere Informationen zu Konto-IDs finden Sie unter [Kontobezeichner](https://docs.snowflake.com/en/user-guide/admin-account-identifier) in der Snowflake-Dokumentation.
+ `sfUser` – (Erforderlich) Wird zum Lesen/Schreiben verwendet. Anmeldename für den Snowflake-Benutzer.
+ `sfPassword` – (Erforderlich, außer `pem_private_key` wurde angegeben). Wird zum Lesen/Schreiben verwendet. Passwort für den Snowflake-Benutzer.
+ `dbtable` – Erforderlich beim Arbeiten mit vollständigen Tabellen. Wird für Lesen/Schreiben verwendet. Der Name der zu lesenden Tabelle bzw. der Tabelle, in die Daten geschrieben werden. Beim Lesen werden alle Spalten und Datensätze abgerufen.
+ `pem_private_key` – Wird zum Lesen/Schreiben verwendet. Eine unverschlüsselte, b64-kodierte Private-Key-Zeichenfolge. Der private Schlüssel für den Snowflake-Benutzer. Es ist üblich, dies aus einer PEM-Datei zu kopieren. Weitere Informationen finden Sie unter [Schlüsselpaar-Authentifizierung und Schlüsselpaar-Rotation](https://docs.snowflake.com/en/user-guide/key-pair-auth) in der Snowflake-Dokumentation.
+ `query` – Beim Lesen mit einer Abfrage erforderlich. Wird zum Lesen verwendet. Die genaue Abfrage (`SELECT`-Anweisung), die ausgeführt werden soll
Die folgenden Optionen werden zum Konfigurieren spezifischer Verhaltensweisen während des Verbindungsvorgangs mit Snowflake verwendet.
+ `preactions` – Wird zum Lesen/Schreiben verwendet. Gültige Werte: Durch Semikolons getrennte Liste von SQL-Anweisungen als Zeichenfolge. SQL-Anweisungen werden ausgeführt, bevor Daten zwischen AWS Glue und Snowflake übertragen werden. Wenn eine Anweisung `%s` enthält, wird `%s` durch den Tabellennamen ersetzt, auf den für die Operation verwiesen wird.
+ `postactions` – Wird zum Lesen/Schreiben verwendet. SQL-Anweisungen werden ausgeführt, nachdem Daten zwischen AWS Glue und Snowflake übertragen wurden. Wenn eine Anweisung `%s` enthält, wird `%s` durch den Tabellennamen ersetzt, auf den für die Operation verwiesen wird.
+ `autopushdown` – Standardwert: `"on"`. Zulässige Werte: `"on"`, `"off"`. Dieser Parameter steuert, ob das automatische Abfrage-Pushdown aktiviert ist. Wenn Pushdown aktiviert ist, wird bei der Ausführung einer Abfrage auf Spark ein Teil der Abfrage auf den Snowflake-Server „heruntergeschoben“, wenn dies möglich ist. Dies verbessert die Leistung einiger Abfragen. Informationen darüber, ob Ihre Abfrage per Pushdown verschoben werden kann, finden Sie unter [Pushdown](https://docs.snowflake.com/en/user-guide/spark-connector-use#pushdown) in der Snowflake-Dokumentation.
Darüber hinaus werden einige der auf dem Snowflake Spark-Konnektor verfügbaren Optionen möglicherweise in AWS Glue unterstützt. Weitere Informationen zu den Optionen, die im Snowflake-Spark-Konnektor verfügbar sind, finden Sie unter [Festlegen von Konfigurationsoptionen für den Konnektor](https://docs.snowflake.com/en/user-guide/spark-connector-use#setting-configuration-options-for-the-connector) in der Snowflake-Dokumentation.
## Snowflake-Authentifizierungsmethoden
AWS Glue unterstützt die folgenden Authentifizierungsmethoden für die Verbindung mit Snowflake:
+ **Authentifizierung mit Benutzername und Passwort:** Geben Sie die Parameter `sfUser` und `sfPassword` an.
+ **Schlüsselpaar-Authentifizierung:** Geben Sie die Parameter `sfUser` und `pem_private_key` an. Bei Verwendung der Schlüsselpaar-Authentifizierung ist der `sfPassword`-Parameter nicht erforderlich.
Beide Authentifizierungsmethoden werden vollständig unterstützt und können mit einer beliebigen Kombination von Verbindungsoptionen, Datenkatalogverbindungen oder AWS Secrets Manager Geheimnissen konfiguriert werden.
## Einschränkungen des Snowflake-Konnektors
Die Verbindung zu Snowflake mit AWS Glue for Spark unterliegt den folgenden Einschränkungen.
+ Dieser Konnektor unterstützt keine Auftragslesezeichen. Weitere Informationen zu Auftragslesezeichen finden Sie unter [Verfolgen von verarbeiteten Daten mit Auftragslesezeichen](monitor-continuations.md).
+ Dieser Konnektor unterstützt keine Snowflake-Lese- und Schreibvorgänge durch Tabellen im AWS Glue-Datenkatalog mit den Methoden `create_dynamic_frame.from_catalog` und`write_dynamic_frame.from_catalog`.
+ Dieser Konnektor unterstützt username/password Authentifizierung und Schlüsselpaar-Authentifizierung. Andere Authentifizierungsmethoden (wie OAuth SAML) werden derzeit nicht unterstützt.
+ Dieser Konnektor wird in Streaming-Aufträgen nicht unterstützt.
+ Dieser Konnektor unterstützt anweisungsbasierte `SELECT`-Abfragen beim Abrufen von Informationen (wie z. B. mit dem `query`-Parameter). Andere Arten von Abfragen (z. B. `SHOW`, `DESC` oder DML-Anweisungen) werden nicht unterstützt.
+ Snowflake begrenzt die Größe des über Snowflake-Clients übermittelten Abfragetextes (d. h. SQL-Anweisungen) auf 1 MB pro Anweisung. Weitere Einzelheiten finden Sie unter [Beschränkungen der Abfragetextgröße](https://docs.snowflake.com/en/user-guide/query-size-limits).
# Teradata-Vantage-Verbindungen
Sie können AWS Glue for Spark verwenden, um in Teradata Vantage in AWS Glue 4.0 und späteren Versionen aus vorhandenen Tabellen zu lesen und in diese zu schreiben. Sie können definieren, was mit einer SQL-Abfrage aus Teradata gelesen werden soll. Sie können eine Verbindung zu Teradata herstellen, indem Sie Benutzernamen und Passwörter verwenden, die AWS Secrets Manager über eine AWS Glue-Verbindung gespeichert sind.
Weitere Informationen zu Teradata finden Sie in der [Teradata-Dokumentation](https://docs.teradata.com/)
## Konfigurieren von Teradata-Verbindungen
Um von AWS Glue aus eine Verbindung zu Teradata herzustellen, müssen Sie Ihre Teradata-Anmeldeinformationen erstellen und in einem AWS Secrets Manager Secret speichern und dieses Secret dann mit einer AWS Glue Teradata-Verbindung verknüpfen. Wenn sich Ihre Teradata-Instance in einer Amazon VPC befindet, müssen Sie auch Netzwerkoptionen für Ihre AWS Glue Teradata-Verbindung bereitstellen.
Um von AWS Glue aus eine Verbindung zu Teradata herzustellen, benötigen Sie möglicherweise einige Voraussetzungen:
+ Wenn Sie über Amazon VPC auf Ihre Teradata-Umgebung zugreifen, konfigurieren Sie Amazon VPC so, dass Ihr AWS Glue-Job mit der Teradata-Umgebung kommunizieren kann. Wir raten davon ab, über das öffentliche Internet auf die Teradata-Umgebung zuzugreifen.
Identifizieren oder erstellen Sie in Amazon VPC eine **VPC**, ein **Subnetz** und eine **Sicherheitsgruppe**, die AWS Glue bei der Ausführung des Jobs verwendet. Darüber hinaus muss Amazon VPC so konfiguriert sein, dass der Netzwerkdatenverkehr zwischen Ihrer Teradata-Instance und diesem Standort zugelassen wird. Ihr Auftrag muss eine TCP-Verbindung mit Ihrem Teradata-Client-Port herstellen. Weitere Informationen zu Teradata-Ports finden Sie in der [Teradata-Dokumentation](https://docs.teradata.com/r/Teradata-VantageTM-on-AWS-DIY-Installation-and-Administration-Guide/April-2020/Before-Deploying-Vantage-on-AWS-DIY/Security-Groups-and-Ports).
Abhängig von Ihrem Netzwerklayout kann eine sichere VPC-Konnektivität Änderungen an Amazon VPC und anderen Netzwerkdiensten erfordern. Weitere Informationen zur Konnektivität finden Sie unter AWS [Konnektivitätsoptionen in der AWS Teradata-Dokumentation](https://docs.teradata.com/r/Teradata-VantageCloud-Enterprise/Get-Started/Connecting-Your-Environment/AWS-Connectivity-Options).
**So konfigurieren Sie eine AWS Glue Teradata-Verbindung:**
1. Identifizieren oder erstellen Sie in Ihrer Teradata-Konfiguration einen Benutzer und ein Passwort, mit dem AWS Glue eine Verbindung herstellt, *teradataUser* und. *teradataPassword* Weitere Informationen finden Sie in der Teradata-Dokumentation unter [Vantage Security Overview.](https://docs.teradata.com/r/Configuring-Teradata-VantageTM-After-Installation/January-2021/Security-Overview/Vantage-Security-Overview)
1. Erstellen Sie AWS Secrets Manager unter Verwendung Ihrer Teradata-Anmeldeinformationen ein Geheimnis. Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial, das in der AWS Secrets Manager Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) verfügbar ist. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `user` mit dem Wert. *teradataUsername*
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `password` mit dem Wert. *teradataPassword*
1. Stellen Sie in der AWS Glue-Konsole eine Verbindung her, indem Sie den Schritten unter folgen[AWS Glue Verbindung hinzufügen](console-connections.md). Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für den nächsten Schritt bei. *connectionName*
+ Wählen Sie als **Verbindungstyp** Teradata aus.
+ Wenn Sie die **IDBC-URL** angeben, geben Sie die URL für Ihre Instance an. Sie können auch bestimmte durch Kommas getrennte Verbindungsparameter in Ihrer JDBC-URL fest codieren. Die URL muss dem folgenden Format entsprechen: `jdbc:teradata://teradataHostname/ParameterName=ParameterValue,ParameterName=ParameterValue`
Zu den unterstützten URL-Parametern gehören:
+ `DATABASE` – Name der Datenbank auf dem Host, auf die standardmäßig zugegriffen werden soll.
+ `DBS_PORT` – der Datenbankport, der verwendet wird, wenn nicht der standardmäßige Port genutzt wird.
+ Wählen Sie bei der Auswahl eines **Anmeldeinformationstyps** die Option **AWS Secrets Manager**und setzen Sie dann **AWS Geheim** auf*secretName*.
1. In den folgenden Situationen ist möglicherweise eine zusätzliche Konfiguration erforderlich:
+
Für Teradata-Instances, die AWS in einer Amazon VPC gehostet werden
+ Sie müssen Amazon VPC-Verbindungsinformationen für die AWS Glue-Verbindung bereitstellen, die Ihre Teradata-Sicherheitsanmeldedaten definiert. Wenn Sie Ihre Verbindung erstellen oder aktualisieren, legen Sie **VPC**, **Subnetz** und **Sicherheitsgruppen** in den **Netzwerkoptionen** fest.
Nachdem Sie eine AWS Glue Teradata-Verbindung hergestellt haben, müssen Sie die folgenden Schritte ausführen, bevor Sie Ihre Verbindungsmethode aufrufen.
+ Erteilen Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle *secretName* Leserechte.
+ Stellen *connectionName* Sie in Ihrer AWS Glue-Job-Konfiguration eine **zusätzliche Netzwerkverbindung** bereit.
## Lesen aus Teradata
**Voraussetzungen:**
+ Eine Teradata-Tabelle, aus der gelesen werden soll. Sie benötigen den Tabellennamen,*tableName*.
+ Eine AWS Glue Teradata-Verbindung, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Gehen Sie wie folgt vor, um eine *Verbindung zu Teradata zu konfigurieren*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
Beispiel:
```
teradata_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName"
}
)
```
Sie können auch eine SELECT-SQL-Abfrage angeben, um die an Ihre zurückgegebenen Ergebnisse zu filtern DynamicFrame. Sie müssen `query` konfigurieren.
Beispiel:
```
teradata_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Schreiben in Teradata-Tabellen
**Voraussetzungen:** Eine Teradata-Tabelle, in die Sie schreiben möchten,. *tableName* **Sie müssen die Tabelle erstellen, bevor Sie die Verbindungsmethode aufrufen.**
Beispiel:
```
teradata_write = glueContext.write_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName"
}
)
```
## Referenz zur Teradata-Verbindungsoption
+ `connectionName` – Erforderlich. Wird für Lesen/Schreiben verwendet. Der Name einer AWS Glue Teradata-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkinformationen für Ihre Verbindungsmethode bereitstellt.
+ `dbtable` – Zum Schreiben erforderlich, zum Lesen erforderlich, sofern `query` nicht angegeben ist. Wird für Lesen/Schreiben verwendet. Der Name einer Tabelle, mit der Ihre Verbindungsmethode interagieren wird.
+ `query` – Wird zum Lesen verwendet. Eine SELECT-SQL-Abfrage, die definiert, was beim Lesen aus Teradata abgerufen werden soll.
# Teradata-Vantage-NOS-Verbindungen
Die Teradata-NOS-Verbindung (Native Object Store) ist eine neue Verbindung für Teradata Vantage, die die Teradata-WRITE\$1NOS-Abfrage zum Lesen aus vorhandenen Tabellen und die READ\$1NOS-Abfrage zum Schreiben in Tabellen nutzt. Diese Abfragen verwenden Amazon S3 als Staging-Verzeichnis. Daher ist der Teradata-NOS-Connector schneller als der bestehende Teradata-Connector (JDBC-basiert), insbesondere bei der Verarbeitung großer Datenmengen.
Sie können die Teradata NOS-Verbindung in AWS Glue für Spark verwenden, um in Teradata Vantage 5.0 und späteren Versionen aus vorhandenen Tabellen zu lesen und in AWS Glue diese zu schreiben. Sie können definieren, was mit einer SQL-Abfrage aus Teradata gelesen werden soll. Sie können eine Verbindung zu Teradata herstellen, indem Sie Benutzernamen und Passwörter verwenden, die in einer Verbindung gespeichert sind. AWS Secrets Manager AWS Glue
Weitere Informationen zu Teradata finden Sie in der [Teradata-Dokumentation](https://docs.teradata.com/).
**Topics**
+ [Erstellen einer Teradata-NOS-Verbindung](#creating-teradata-nos-connection)
+ [Lesen aus Teradata-Tabellen](#reading-from-teradata-nos-tables)
+ [Schreiben in Teradata-Tabellen](#writing-to-teradata-nos-tables)
+ [Referenz zur Teradata-Verbindungsoption](#teradata-nos-connection-option-reference)
+ [Stellen Sie Optionen in der AWS Glue Visual ETL-Benutzeroberfläche bereit](#teradata-nos-connection-option-visual-etl-ui)
## Erstellen einer Teradata-NOS-Verbindung
Um von aus eine Verbindung zu Teradata NOS herzustellen AWS Glue, müssen Sie Ihre Teradata-Anmeldeinformationen in einem AWS Secrets Manager geheimen Ordner erstellen und speichern und dieses Geheimnis dann einer Teradata NOS-Verbindung zuordnen. AWS Glue Wenn sich Ihre Teradata-Instance in einer Amazon VPC befindet, müssen Sie auch Netzwerkoptionen für Ihre AWS Glue Teradata NOS-Verbindung bereitstellen.
**Voraussetzungen:**
+ Wenn Sie über Amazon VPC auf Ihre Teradata-Umgebung zugreifen, konfigurieren Sie Amazon VPC so, dass Ihr AWS Glue Job mit der Teradata-Umgebung kommunizieren kann. Wir raten davon ab, über das öffentliche Internet auf die Teradata-Umgebung zuzugreifen.
+ Identifizieren oder erstellen Sie in Amazon VPC eine VPC, ein Subnetz und eine Sicherheitsgruppe, die bei der Ausführung des Jobs verwendet AWS Glue werden. Darüber hinaus muss Amazon VPC so konfiguriert sein, dass der Netzwerkdatenverkehr zwischen Ihrer Teradata-Instance und diesem Standort zugelassen wird. Ihr Auftrag muss eine TCP-Verbindung mit Ihrem Teradata-Client-Port herstellen. Weitere Informationen zu Teradata-Ports finden Sie unter [Sicherheitsgruppen für Teradata Vantage](https://docs.teradata.com/r/Teradata-VantageTM-on-AWS-DIY-Installation-and-Administration-Guide/April-2020/Before-Deploying-Vantage-on-AWS-DIY/Security-Groups-and-Ports).
+ Abhängig von Ihrem Netzwerklayout kann eine sichere VPC-Konnektivität Änderungen an Amazon VPC und anderen Netzwerkdiensten erfordern. Weitere Informationen zur Konnektivität finden Sie unter AWS [AWS Konnektivitätsoptionen](https://docs.teradata.com/r/Teradata-VantageCloud-Enterprise/Get-Started/Connecting-Your-Environment/AWS-Connectivity-Options) in der Teradata-Dokumentation.
### So konfigurieren Sie eine AWS Glue Teradata NOS-Verbindung:
1. Identifizieren oder erstellen Sie in Ihrer Teradata-Konfiguration eine *teradataUsername* und *teradataPassword* AWS Glue stellen Sie eine Verbindung her mit. Weitere Informationen finden Sie in der Teradata-Dokumentation unter [Vantage Security Overview.](https://docs.teradata.com/r/Configuring-Teradata-VantageTM-After-Installation/January-2021/Security-Overview/Vantage-Security-Overview)
1. Erstellen Sie AWS Secrets Manager unter Verwendung Ihrer Teradata-Anmeldeinformationen ein Geheimnis. Um ein Geheimnis zu erstellen AWS Secrets Manager, folgen Sie dem Tutorial, das in der Dokumentation unter [Create an AWS Secrets Manager Secret verfügbar ist AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html). Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
+ Wenn Sie Key/value Paare auswählen, erstellen Sie ein Paar für den Schlüssel USERNAME mit dem Wert*teradataUsername*.
+ Wenn Sie Key/value Paare auswählen, erstellen Sie ein Paar für den Schlüssel PASSWORD mit dem Wert*teradataPassword*.
1. Erstellen Sie in der AWS Glue Konsole eine Verbindung, indem Sie den Schritten unter [AWS Glue Verbindung hinzufügen](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html) folgen. Behalten Sie nach dem Erstellen der Verbindung den Verbindungsnamen für den nächsten Schritt bei. *connectionName*
+ Wählen Sie als **Verbindungstyp** Teradata Vantage NOS aus.
+ Wenn Sie die IDBC-URL angeben, geben Sie die URL für Ihre Instance an. Sie können auch bestimmte durch Kommas getrennte Verbindungsparameter in Ihrer JDBC-URL fest codieren. Die URL muss dem folgenden Format entsprechen: ` jdbc:teradata://teradataHostname/ParameterName=ParameterValue,ParameterName=ParameterValue `
+ Zu den unterstützten URL-Parametern gehören:
+ `DATABASE` – Name der Datenbank auf dem Host, auf die standardmäßig zugegriffen werden soll.
+ `DBS_PORT` – der Datenbankport, der verwendet wird, wenn nicht der standardmäßige Port genutzt wird.
+ Wählen Sie bei der Auswahl eines **Anmeldeinformationstyps** die Option AWS Secrets Manager und setzen Sie dann ** AWS Geheim** auf*secretName*.
1. In den folgenden Situationen ist möglicherweise eine zusätzliche Konfiguration erforderlich:
+ Für Teradata-Instances, die auf AWS einer Amazon VPC gehostet werden, müssen Sie Amazon VPC-Verbindungsinformationen für die Verbindung bereitstellen, die Ihre AWS Glue Teradata-Sicherheitsanmeldedaten definiert. Wenn Sie Ihre Verbindung erstellen oder aktualisieren, legen Sie **VPC**, **Subnetz** und **Sicherheitsgruppen** in den **Netzwerkoptionen** fest.
Nachdem Sie eine AWS Glue Teradata Vantage NOS-Verbindung hergestellt haben, müssen Sie die folgenden Schritte ausführen, bevor Sie Ihre Verbindungsmethode aufrufen.
1. Erteilen Sie der mit Ihrem AWS Glue Job verknüpften IAM-Rolle Leserechte. *secretName*
1. Stellen *connectionName* Sie in Ihrer AWS Glue Jobkonfiguration unter **Verbindungen** eine **zusätzliche Netzwerkverbindung** bereit.
## Lesen aus Teradata-Tabellen
### Voraussetzungen:
+ Eine Teradata-Tabelle, aus der gelesen werden soll. Sie benötigen den Tabellennamen,*tableName*.
+ Die Teradata-Umgebung hat Schreibzugriff auf den Amazon S3 S3-Pfad, der in der `staging_fs_url` Option, angegeben ist. *stagingFsUrl*
+ Die mit dem AWS Glue Job verknüpfte IAM-Rolle hat Schreibzugriff auf den Amazon S3 S3-Standort, der in der `staging_fs_url` Option angegeben ist.
+ Eine AWS Glue Teradata NOS-Verbindung, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Führen Sie die Schritte in [So konfigurieren Sie eine AWS Glue Teradata NOS-Verbindung:](#creating-teradata-nos-connection-procedure) aus, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der Verbindung,. AWS Glue *connectionName*
Beispiel:
```
teradata_read_table = glueContext.create_dynamic_frame.from_options(
connection_type= "teradatanos",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"staging_fs_url": "stagingFsUrl"
}
)
```
Sie können auch eine SELECT-SQL-Abfrage angeben, um die an Ihre zurückgegebenen Ergebnisse zu filtern DynamicFrame. Sie müssen die Abfrage konfigurieren. Wenn Sie sowohl dbTable als auch die Abfrage konfigurieren, kann der Connector die Daten nicht lesen. Beispiel:
```
teradata_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="teradatanos",
connection_options={
"connectionName": "connectionName",
"query": "query",
"staging_fs_url": "stagingFsUrl"
}
)
```
Darüber hinaus können Sie die DataFrame Spark-API verwenden, um aus Teradata-Tabellen zu lesen. Beispiel:
```
options = {
"url": "JDBC_URL",
"dbtable": "tableName",
"user": "teradataUsername", # or use "username" as key here
"password": "teradataPassword",
"staging_fs_url": "stagingFsUrl"
}
teradata_read_table = spark.read.format("teradatanos").option(**options).load()
```
## Schreiben in Teradata-Tabellen
### Voraussetzungen
+ Eine Teradata-Tabelle, in die Sie schreiben möchten:. *tableName*
+ Die Teradata-Umgebung hat Lesezugriff auf den Amazon S3 S3-Standort, der in der `staging_fs_url` Option, angegeben ist. * stagingFsUrl *
+ Die mit dem AWS Glue Job verknüpfte IAM-Rolle hat Schreibzugriff auf den Amazon S3 S3-Standort, der in der `staging_fs_url` Option angegeben ist.
+ Eine AWS Glue Teradata-Verbindung, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Führen Sie die Schritte in [So konfigurieren Sie eine AWS Glue Teradata NOS-Verbindung:](#creating-teradata-nos-connection-procedure) aus, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der Verbindung,. AWS Glue *connectionName*
Beispiel:
```
teradata_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type= "teradatanos",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"staging_fs_url": "stagingFsUrl"
}
)
```
## Referenz zur Teradata-Verbindungsoption
**Verbindungs- und Operationsoptionen:**
+ `connectionName` – Erforderlich. Wird für Lesen/Schreiben verwendet. Der Name einer AWS Glue Teradata-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkinformationen für Ihre Verbindungsmethode bereitstellt.
+ `staging_fs_url` – Erforderlich. Wird für Lesen/Schreiben verwendet. Ein beschreibbarer Speicherort in Amazon S3, der für entladene Daten beim Lesen aus Teradata und für Parquet-Daten verwendet wird, die beim Schreiben in Teradata in Redshift geladen werden sollen. Der S3-Bucket muss sich in derselben Region wie die Region Ihrer Jobs befinden. AWS Glue
+ `dbtable` – Zum Schreiben erforderlich, zum Lesen erforderlich, sofern `query` nicht angegeben ist. Wird für Lesen/Schreiben verwendet. Der Name einer Tabelle, mit der Ihre Verbindungsmethode interagieren wird.
+ `query` – Wird zum Lesen verwendet. Eine SELECT-SQL-Abfrage, die definiert, was beim Lesen aus Teradata abgerufen werden soll. Voraussetzung ist, dass die Option `dbtable` angegeben ist.
+ `clean_staging_s3_dir`— Fakultativ. Wird für Lesen/Schreiben verwendet. Falls „True“, werden die Amazon-S3-Staging-Objekte nach einem Lese- oder Schreibvorgang bereinigt. Der Standardwert ist "True".
+ `pre_actions`— Fakultativ. Wird zum Schreiben verwendet. Eine durch Semikolons getrennte Liste von SQL-Befehlen, die ausgeführt werden, bevor Daten zwischen Spark und Teradata Vantage übertragen werden.
+ `post_actions`— Fakultativ. Wird zum Schreiben verwendet. Eine durch Semikolons getrennte Liste von SQL-Befehlen, die ausgeführt werden, nachdem Daten zwischen Spark und Teradata Vantage übertragen wurden.
+ `truncate`— Fakultativ. Wird zum Schreiben verwendet. Falls „True“, kürzt der Connector die Tabelle, wenn im Überschreibenmodus geschrieben wird. Wenn der Wert „False“ ist, löscht der Connector die Tabelle, wenn im Überschreibenmodus geschrieben wird. Der Standardwert ist "false".
+ `create_table_script`— Fakultativ. Wird zum Schreiben verwendet. Eine SQL-Anweisung zum Erstellen einer Tabelle beim Schreiben in Teradata Vantage. Nützlich, wenn Sie eine Tabelle mit benutzerdefinierten Metadaten erstellen möchten (z. B. CREATE MULTISET oder SET TABLE oder Änderung des Primärindex). Beachten Sie, dass der im Skript zum Erstellen einer Tabelle verwendete Tabellenname mit dem in der Option `dbtable` angegebenen Tabellennamen übereinstimmen sollte.
+ `partition_size_in_mb`— Fakultativ. Zum Lesen verwendet. Maximale Größe einer Spark-Partition in Megabyte beim Lesen von Amazon-S3-Staging-Objekten. Der Standardwert lautet 128.
Sie können bei der Erstellung eines Teradata-Knotens erweiterte Optionen angeben. Diese Optionen sind dieselben wie bei der Programmierung AWS Glue für Spark-Skripte.
Siehe [Teradata-Vantage-Verbindungen](aws-glue-programming-etl-connect-teradata-home.md).
**Autorisierungsoptionen:**
Im Folgenden finden Sie Optionen zur Bereitstellung von AWS Kontoanmeldeinformationen, die der Connector für den Zugriff auf den Amazon S3 S3-Staging-Bucket verwendet. Sie können wählen, (1) überhaupt keine Autorisierungsoptionen bereitzustellen und temporäre Anmeldeinformationen zu verwenden, die von Ihrer AWS Glue Ausführungsrolle generiert wurden; oder (2) ein von Ihnen erstelltes Autorisierungsobjekt bereitzustellen; oder (3) anzugeben, `auth_object` `aws_access_key_id and aws_secret_access_key` falls langfristige Anmeldeinformationen verwendet werden, oder, `aws_access_key``aws_secret_access_key`, bereitzustellen und `aws_session_token` temporäre Anmeldeinformationen zu verwenden.
+ `auth_object` – Optional. Wird für den Zugriff auf den Amazon-S3-Bucket verwendet. Eine Zeichenfolge für ein Autorisierungsobjekt, die in einer Teradata-Instance erstellt wurde. Falls angegeben, verwendet der Connector dieses Autorisierungsobjekt, um auf den Amazon-S3-Staging-Bucket zuzugreifen. Falls nicht angegeben `aws_access_key_id` und auch nicht bereitgestellt `aws_secret_access_key` werden, werden temporäre Anmeldeinformationen aus der AWS Glue Ausführungsrolle abgerufen und vom Connector verwendet. Das mit diesem Autorisierungsobjekt verknüpfte AWS Konto muss sich in derselben Region wie Ihre AWS Glue Jobs und Ihr Amazon S3 S3-Staging-Bucket befinden oder mit kontoübergreifender Vertrauensstellung konfiguriert sein.
+ `aws_access_key_id` – Optional. Wird für den Zugriff auf den Amazon-S3-Bucket verwendet. Teil eines Sicherheitsnachweises für ein AWS Konto. Wenn `auth_object` nicht angegeben ist und `aws_secret_access_key` mit `aws_access_key_id` bereitgestellt wird, verwendet der Connector sie, um auf den Amazon-S3-Staging-Bucket zuzugreifen. Das mit diesem Zugriffsschlüssel verknüpfte AWS Konto muss sich in derselben Region wie Ihre AWS Glue Jobs und Ihr Amazon S3 S3-Staging-Bucket befinden oder mit kontoübergreifender Vertrauensstellung konfiguriert sein.
+ `aws_secret_access_key` – Optional. Wird für den Zugriff auf den Amazon-S3-Bucket verwendet. Teil eines Sicherheitsnachweises für ein AWS Konto. Wenn `auth_object` nicht angegeben ist und `aws_access_key_id` mit `aws_secret_access_key` bereitgestellt wird, verwendet der Connector sie, um auf den Amazon-S3-Staging-Bucket zuzugreifen. Das mit diesem geheimen Schlüssel verknüpfte AWS Konto muss sich in derselben Region wie Ihre AWS Glue Jobs und Ihr Amazon S3 S3-Staging-Bucket befinden oder mit kontoübergreifender Vertrauensstellung konfiguriert sein.
+ `aws_session_token` – Optional. Wird für den Zugriff auf den Amazon-S3-Bucket verwendet. Teil eines temporären AWS Konto-Sicherheitsnachweises. Sollte mit `aws_access_key_id` und `aws_secret_access_key` bereitgestellt werden.
## Stellen Sie Optionen in der AWS Glue Visual ETL-Benutzeroberfläche bereit
Sie können alle oben genannten Optionen auf Ihrer Visual-ETL-Auftrags-UI bereitstellen. Für die connectionName-Option sollten Sie sie aus der Dropdownliste der Teradata-Vantage-NOS-Verbindung auswählen. Für alle anderen Optionen sollten Sie sie über die benutzerdefinierten Teradata-Vantage-NOS-Eigenschaften als Schlüssel/Wert-Paare angeben.
![\[Im Fensterbereich wird angezeigt, dass die Teradata-NOS-Vantage-Verbindung ausgewählt ist.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/teradata-nos-vantage-connection-options.png)
# Vertica-Verbindungen
In AWS Glue 4.0 und späteren Versionen können Sie Glue for Spark verwenden, um aus Tabellen in Vertica zu lesen und in AWS Tabellen zu schreiben. Sie können definieren, was mit einer SQL-Abfrage aus Vertica gelesen werden soll. Sie stellen eine Verbindung zu Vertica her, indem Sie Benutzername und Passwort verwenden, die AWS Secrets Manager über eine AWS Glue-Verbindung gespeichert sind.
Weitere Informationen zu Vertica finden Sie in der [Vertica-Dokumentation](https://www.vertica.com/docs/9.3.x/HTML/Content/Authoring/UsingVerticaOnAWS/UsingVerticaOnAWS.htm).
## Konfigurieren von Vertica-Verbindungen
Um von AWS Glue aus eine Verbindung zu Vertica herzustellen, müssen Sie Ihre Vertica-Anmeldeinformationen erstellen und in einem AWS Secrets Manager geheimen Ordner speichern und dieses Geheimnis dann mit einer Vertica AWS Glue-Verbindung verknüpfen. Wenn sich Ihre Vertica-Instance in einer Amazon VPC befindet, müssen Sie auch Netzwerkoptionen für Ihre AWS Glue Vertica-Verbindung bereitstellen. Sie benötigen einen Amazon-S3-Bucket oder -Ordner zur temporären Speicherung beim Lesen und Schreiben in die Datenbank.
Um von AWS Glue aus eine Verbindung zu Vertica herzustellen, benötigen Sie einige Voraussetzungen:
+ Ein Amazon S3 S3-Bucket oder -Ordner, der als temporärer Speicher verwendet wird, wenn aus der Datenbank gelesen und in die Datenbank geschrieben wird, auf den von*tempS3Path*.
**Anmerkung**
Wenn Sie Vertica in der Vorschau von AWS Glue-Auftragsdaten verwenden, werden temporäre Dateien möglicherweise nicht automatisch entfernt. *tempS3Path* Um sicherzustellen, dass temporäre Dateien entfernt werden, beenden Sie die Datenvorschau-Sitzung direkt, indem Sie im Bereich **Datenvorschau** die Option **Sitzung beenden** wählen.
Wenn Sie nicht garantieren können, dass die Datenvorschau-Sitzung direkt beendet wird, sollten Sie die Amazon-S3-Lifecycle-Konfiguration so einrichten, dass alte Daten entfernt werden. Wir empfehlen, Daten zu entfernen, die älter als 49 Stunden sind, basierend auf der maximalen Auftragslaufzeit zuzüglich einer Marge. Weitere Informationen zur Konfiguration des Amazon-S3-Lebenszyklus finden Sie in der Amazon-S3-Dokumentation unter [Verwalten Ihres Speicherlebenszyklus](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html).
+ Eine IAM-Richtlinie mit entsprechenden Berechtigungen für Ihren Amazon S3-Pfad, die Sie Ihrer AWS Glue-Jobrolle zuordnen können.
+ Wenn sich Ihre Vertica-Instance in einer Amazon VPC befindet, konfigurieren Sie Amazon VPC so, dass Ihr AWS Glue-Job mit der Vertica-Instance kommunizieren kann, ohne dass der Datenverkehr das öffentliche Internet durchquert.
Identifizieren oder erstellen Sie in Amazon VPC eine **VPC**, ein **Subnetz** und eine **Sicherheitsgruppe**, die AWS Glue bei der Ausführung des Jobs verwendet. Darüber hinaus muss Amazon VPC so konfiguriert sein, dass der Netzwerkdatenverkehr zwischen Ihrer Vertica-Instance und diesem Standort zugelassen wird. Ihr Auftrag muss eine TCP-Verbindung mit Ihrem Vertica-Client-Port (Standard 5433) herstellen. Abhängig von Ihrem Netzwerklayout kann dies Änderungen an den Sicherheitsgruppenregeln, dem Netzwerk ACLs, den NAT-Gateways und den Peering-Verbindungen erfordern.
Sie können dann mit der Konfiguration von AWS Glue für die Verwendung mit Vertica fortfahren.
**Eine Verbindung zu Vertica konfigurieren Sie wie folgt:**
1. Erstellen Sie AWS Secrets Manager unter Verwendung Ihrer Vertica-Anmeldeinformationen einen geheimen Schlüssel, und*verticaUsername*. *verticaPassword* Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial, das in der AWS Secrets Manager Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) verfügbar ist. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Geheimnamen *secretName* für den nächsten Schritt bei.
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `user` mit dem Wert. *verticaUsername*
+ Wenn Sie **Schlüssel/Wert-Paare** auswählen, erstellen Sie ein Paar für den Schlüssel `password` mit dem Wert. *verticaPassword*
1. Stellen Sie in der AWS Glue-Konsole eine Verbindung her, indem Sie den Schritten unter folgen[AWS Glue Verbindung hinzufügen](console-connections.md). Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für den nächsten Schritt bei. *connectionName*
+ Wählen Sie als **Verbindungstyp** Vertica aus.
+ Geben Sie als **Vertica-Host** den Hostnamen Ihrer Vertica-Installation an.
+ Geben Sie als **Vertica-Port** den Port an, über den Ihre Vertica-Installation verfügbar ist.
+ Geben Sie bei der Auswahl eines **AWS Geheimnisses** Folgendes an*secretName*.
1. In den folgenden Situationen ist möglicherweise eine zusätzliche Konfiguration erforderlich:
+
Für Vertica-Instances, die AWS in einer Amazon VPC gehostet werden
+ Stellen Sie Amazon VPC-Verbindungsinformationen für die AWS Glue-Verbindung bereit, die Ihre Vertica-Sicherheitsanmeldedaten definiert. Wenn Sie Ihre Verbindung erstellen oder aktualisieren, legen Sie **VPC**, **Subnetz** und **Sicherheitsgruppen** in den **Netzwerkoptionen** fest.
Nachdem Sie eine AWS Glue Vertica-Verbindung hergestellt haben, müssen Sie die folgenden Schritte ausführen, bevor Sie Ihre Verbindungsmethode aufrufen.
+ Erteilen Sie die mit Ihrem AWS Glue-Job verknüpfte IAM-Rolle für. *tempS3Path*
+ Erteilen Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle *secretName* Leserechte.
+ Stellen *connectionName* Sie in Ihrer AWS Glue-Job-Konfiguration eine **zusätzliche Netzwerkverbindung** bereit.
## Lesen aus Vertica
**Voraussetzungen:**
+ Eine Vertica-Tabelle, aus der gelesen werden soll. Sie benötigen den Vertica-Datenbanknamen *dbName* und den Tabellennamen. *tableName*
+ Eine AWS Glue Vertica-Verbindung, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Gehen Sie wie im vorherigen Verfahren beschrieben vor, *um eine Verbindung zu Vertica zu konfigurieren*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
+ Ein Amazon-S3-Bucket oder -Ordner, der (wie zuvor erwähnt) für den temporären Speicher verwendet werden soll. Sie benötigen den Namen,*tempS3Path*. Sie müssen über das `s3a`-Protokoll eine Verbindung zu diesem Standort herstellen.
Beispiel:
```
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"table": "tableName",
}
)
```
Sie können auch eine SELECT-SQL-Abfrage angeben, um die an Sie zurückgegebenen Ergebnisse zu filtern DynamicFrame oder um auf einen Datensatz aus mehreren Tabellen zuzugreifen.
Beispiel:
```
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"query": "select * FROM tableName",
},
)
```
## Schreiben in Vertica-Tabellen
In diesem Beispiel werden Informationen aus einer vorhandenen Datei DynamicFrame *dynamicFrame* in Vertica geschrieben. Wenn die Tabelle bereits Informationen enthält, hängt AWS Glue Daten von Ihnen DynamicFrame an.
**Voraussetzungen:**
+ Ein aktueller oder gewünschter Tabellenname*tableName*, in den Sie schreiben möchten. Sie benötigen außerdem den entsprechenden Vertica-Datenbanknamen,*dbName*.
+ Eine AWS Glue Vertica-Verbindung, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Gehen Sie wie im vorherigen Verfahren beschrieben vor, *um eine Verbindung zu Vertica zu konfigurieren*, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS Glue-Verbindung,*connectionName*.
+ Ein Amazon-S3-Bucket oder -Ordner, der (wie zuvor erwähnt) für den temporären Speicher verwendet werden soll. Sie benötigen den Namen,*tempS3Path*. Sie müssen über das `s3a`-Protokoll eine Verbindung zu diesem Standort herstellen.
Beispiel:
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"table": "tableName",
}
)
```
## Referenz zur Vertica-Verbindungsoption
+ `connectionName` – Erforderlich. Wird für Lesen/Schreiben verwendet. Der Name einer AWS Glue Vertica-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkinformationen für Ihre Verbindungsmethode bereitstellt.
+ `db` – Erforderlich. Wird für Lesen/Schreiben verwendet. Der einer Datenbank in Vertica, mit dem Ihre Verbindungsmethode interagieren wird.
+ `dbSchema` – Erforderlich, um ggf. Ihre Tabelle zu identifizieren. Wird für Lesen/Schreiben verwendet. Standard: `public`. Der Name eines Schemas, mit dem Ihre Verbindungsmethode interagieren wird.
+ `table` – Zum Schreiben erforderlich, zum Lesen erforderlich, sofern `query` nicht angegeben ist. Wird für Lesen/Schreiben verwendet. Der Name einer Tabelle, mit der Ihre Verbindungsmethode interagieren wird.
+ `query` – Wird zum Lesen verwendet. Eine SELECT-SQL-Abfrage, die definiert, was beim Lesen aus Teradata abgerufen werden soll.
+ `staging_fs_url` – Erforderlich. Wird für Lesen/Schreiben verwendet. Gültige Werte:. `s3a` URLs Die URL eines Amazon-S3-Buckets oder -Ordners, der für den temporären Speicher verwendet werden soll.
## DataFrame Optionen für ETL in AWS Glue 5.0 für Spark
A DataFrame ist ein Datensatz, der ähnlich einer Tabelle in benannte Spalten organisiert ist und Operationen im Funktionsstil (map/reduce/filter/etc.) und SQL-Operationen (Select, Project, Aggregate) unterstützt.
Um eine DataFrame für eine von Glue unterstützte Datenquelle zu erstellen, ist Folgendes erforderlich:
+ Datenquellen-Connector `ClassName`
+ Datenquellen-Verbindung `Options`
In ähnlicher Weise sind dieselben erforderlich, DataFrame um in eine von Glue unterstützte Datensenke zu schreiben:
+ Datensenke-Connector `ClassName`
+ Datensenke-Verbindung `Options`
Beachten Sie, dass AWS Glue-Funktionen wie Job-Lesezeichen und DynamicFrame Optionen wie in nicht unterstützt `connectionName` werden DataFrame. Weitere Informationen zu DataFrame und den unterstützten Vorgängen finden Sie in der Spark-Dokumentation für [DataFrame](https://spark.apache.org/docs/3.5.2/api/python/reference/pyspark.sql/dataframe.html).
### Den Konnektor angeben ClassName
Um `ClassName` einer Datenquelle/Datensenke anzugeben, verwenden Sie die `.format`-Option, um den entsprechenden `ClassName`-Connector bereitzustellen, der die Datenquelle/Datensenke definiert.
**JDBC-Konnektoren**
Geben Sie für JDBC-Connectors `jdbc` als Wert der Option `.format` an und geben Sie den JDBC-Treiber `ClassName` in der `driver`-Option an.
```
df = spark.read.format("jdbc").option("driver", "")...
df.write.format("jdbc").option("driver", "")...
```
In der folgenden Tabelle ist der JDBC-Treiber `ClassName` der unterstützten Datenquelle in AWS Glue for aufgeführt. DataFrames
| Datenquelle | Treiber ClassName |
| --- |--- |
| PostgreSQL | org.postgresql.Driver |
| Oracle | oracle.jdbc.driver. OracleDriver |
| SQLServer | com.microsoft.sqlserver.jdbc. SQLServerTreiber |
| MySQL | com.mysql.jdbc.Driver |
| SAPHana | com.sap.db.jdbc.Treiber |
| Teradata | com.teradata.jdbc. TeraDriver |
**Spark-Connectors**
Geben Sie für Spark-Connectors den `ClassName` des Connectors als Wert der `.format`-Option an.
```
df = spark.read.format("")...
df.write.format("")...
```
In der folgenden Tabelle ist der Spark-Konnektor `ClassName` der unterstützten Datenquelle in AWS Glue for aufgeführt DataFrames.
| Datenquelle | ClassName |
| --- |--- |
| MongoDB/DocumentDB | glue.spark.mongodb |
| Redshift | io.github.spark\$1redshift\$1community.spark.redshift |
| AzureCosmos | kosmos.oltp |
| AzureSQL | com.microsoft.sqlserver.jdbc.spark |
| BigQuery | com.google.cloud.spark.bigquery |
| OpenSearch | org.opensearch.spark.sql |
| Snowflake | net.snowflake.spark.snowflake |
| Vertica | com.vertica.spark.Datenquelle. VerticaSource |
### Angeben der Verbindungsoptionen
Um die `Options` der Verbindung zu einer Datenquelle/Datensenke anzugeben, verwenden Sie `.option(, )`, um einzelne Optionen bereitzustellen, oder `.options(