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