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.
# 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=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:
**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:
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\+ 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\_result\_cache | 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\_s3\_format | Nein | PARQUET | PARQUET – Entlädt die Abfrageergebnisse im Parquet-Format.
TEXT – Entlädt die Abfrageergebnisse im durch Pipes getrennten Textformat. |
| sse\_kms\_key | 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":"<{{KMS_KEY_ID}}>"},
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}}
```