Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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.
# Verwenden der Amazon Redshift Data API
Die Amazon Redshift Data API vereinfacht den Zugriff auf Ihr Amazon Redshift Data Warehouse, da keine Verwaltung von Datenbanktreibern, Verbindungen, Netzwerkkonfigurationen, Datenpufferung, Anmeldeinformationen usw. mehr erforderlich ist. Sie können SQL-Anweisungen mithilfe der Daten-API-Operationen mit dem AWS SDK ausführen. Weitere Informationen zu den Data-API-Operationen finden Sie in der [Amazon-Redshift-Data-API-Referenz](https://docs.aws.amazon.com/redshift-data/latest/APIReference/).
Die Data API erfordert keine persistente Verbindung zu Ihrer Datenbank. Stattdessen bietet es einen sicheren HTTP-Endpunkt und eine Integration mit AWS SDKs. Über den Endpunkt können Sie SQL-Anweisungen ausführen, ohne Verbindungen zu verwalten. Aufrufe der Data API erfolgen asynchron. Die Daten-API kann entweder in gespeicherten Anmeldeinformationen AWS Secrets Manager oder temporäre Datenbankanmeldedaten verwenden. Bei keiner der Autorisierungsmethoden müssen Sie Passwörter in den API-Aufrufen übergeben. Weitere Informationen zu AWS Secrets Manager finden Sie unter [Was ist AWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) im *AWS Secrets Manager Benutzerhandbuch*. Sie können es auch AWS IAM Identity Center für die Autorisierung verwenden.
Mit der Daten-API können Sie mit Webservice-basierten Anwendungen, einschließlich AWS Lambda Amazon AI-Notebooks und, programmgesteuert auf Amazon SageMaker Redshift-Daten zugreifen. AWS Cloud9 Weitere Informationen zu diesen Anwendungen finden Sie [AWS Lambda](https://aws.amazon.com/lambda/)unter [Amazon SageMaker AI](https://aws.amazon.com/sagemaker/) und [AWS Cloud9](https://aws.amazon.com/cloud9/).
Weitere Informationen zur Data API finden Sie unter [Get started with the Amazon Redshift Data API](https://aws.amazon.com/blogs/big-data/get-started-with-the-amazon-redshift-data-api/) im *AWS Big Data Blog*.
## Arbeiten mit der Amazon Redshift Data API
Bevor Sie die Amazon Redshift Data API verwenden, überprüfen Sie die folgenden Schritte:
1. Ermitteln Sie, ob Sie als Aufrufer der Data API autorisiert sind. Weitere Informationen zur -Autorisierung finden Sie unter [Autorisieren des Zugriffs auf die Amazon Redshift Data API](data-api-access.md).
1. Ermitteln Sie, ob Sie planen, die Data API mit Authentifizierungsanmeldeinformationen von Secrets Manager oder temporären Anmeldeinformationen aufzurufen oder AWS IAM Identity Center zu verwenden. Weitere Informationen finden Sie unter [Auswählen der Anmeldeinformationen für die Datenbankauthentifizierung beim Aufrufen der Amazon Redshift Data API](#data-api-calling-considerations-authentication).
1. Richten Sie ein Secret ein, wenn Sie Secrets Manager für die Authentifizierungsanmeldeinformationen verwenden. Weitere Informationen finden Sie unter [Speichern von Datenbankanmeldedaten in AWS Secrets Manager](data-api-secrets.md).
1. Beachten Sie die Punkte und Einschränkungen, die beim Aufrufen der Data API zu berücksichtigen sind. Weitere Informationen finden Sie unter [Wichtige Punkte beim Aufrufen der Amazon Redshift Data API](#data-api-calling-considerations).
1. Rufen Sie die Daten-API über AWS Command Line Interface (AWS CLI), über Ihren eigenen Code oder mithilfe des Abfrage-Editors in der Amazon Redshift Redshift-Konsole auf. Beispiele für den Aufruf über die AWS CLI finden Sie unter [Aufrufen der Daten-API](data-api-calling.md).
## Wichtige Punkte beim Aufrufen der Amazon Redshift Data API
Beachten Sie Folgendes, wenn Sie die Data API aufrufen:
+ Die Amazon Redshift Data API kann auf Datenbanken in von Amazon Redshift bereitgestellten Clustern und Redshift-Serverless-Arbeitsgruppen zugreifen. Eine Liste, AWS-Regionen wo die Redshift Data API verfügbar ist, finden Sie in den Endpunkten, die für die [Redshift Data API](https://docs.aws.amazon.com/general/latest/gr/redshift-service.html) aufgeführt sind. *Allgemeine Amazon Web Services-Referenz*
+ Die maximale Dauer einer Abfrage beträgt 24 Stunden.
+ Die maximale Anzahl aktiver Abfragen (`STARTED`und `SUBMITTED` Abfragen) pro Amazon Redshift Redshift-Cluster beträgt 500.
+ Die maximale Abfrageergebnisgröße beträgt 500 MB (nach Gzip-Komprimierung). Wenn ein Anruf mehr als 500 MB Antwortdaten zurückgibt, wird der Anruf beendet.
+ Die maximale Aufbewahrungszeit für Abfrageergebnisse beträgt 24 Stunden.
+ Die maximale Größe von Abfrageanweisungen beträgt 100 KB.
+ Die Data API ist für die Abfrage von Clustern mit einem Knoten und mehreren Knoten der folgenden Knotentypen verfügbar:
+ dc2.large
+ dc2.8xlarge
+ ra3.large
+ ra3.xlplus
+ ra3.4xlarge
+ ra3.16xlarge
+ Der Cluster muss sich in einer auf dem Amazon-VPC-Service basierenden Virtual Private Cloud (VPC) befinden.
+ Standardmäßig können Benutzer mit derselben IAM-Rolle wie der Ausführer eines `ExecuteStatement`- oder `BatchExecuteStatement`-API-Vorgangs auf dieselbe Anweisung mit `CancelStatement`-, `DescribeStatement`-, `GetStatementResult`- `GetStatementResultV2`- und `ListStatements`-API-Vorgängen reagieren. Um auf dieselbe SQL-Anweisung eines anderen Benutzers reagieren zu können, muss der Benutzer die IAM-Rolle des Benutzers übernehmen können, der die SQL-Anweisung ausgeführt hat. Weitere Informationen zum Übernehmen einer Rolle finden Sie unter [Autorisieren des Zugriffs auf die Amazon Redshift Data API](data-api-access.md).
+ Die SQL-Anweisungen im Parameter `Sqls` der API-Operation `BatchExecuteStatement` werden als eine einzige Transaktion ausgeführt. Sie werden seriell in der Reihenfolge des Arrays ausgeführt. Nachfolgende SQL-Anweisungen werden erst gestartet, wenn die vorherige Anweisung im Array abgeschlossen ist. Wenn eine SQL-Anweisung fehlschlägt, wird die gesamte Arbeit zurückgesetzt, da die Anweisungen als eine Transaktion ausgeführt werden.
+ Die maximale Aufbewahrungszeit für ein Client-Token, das in der API-Operation `ExecuteStatement` oder `BatchExecuteStatement` verwendet wird, beträgt 8 Stunden.
+ Wenn die von Amazon Redshift bereitgestellten Cluster und die Redshift Serverless Workgroup mit einem vom Kunden verwalteten Schlüssel verschlüsselt werden, gewährt Redshift einen Zuschuss, der es der Redshift Data API ermöglicht, den Schlüssel für ihre Operationen zu verwenden. Weitere Informationen finden Sie unter [Verwendung AWS KMS mit der Amazon Redshift Data API](data-api-kms.md).
+ Jede API in der Redshift-Daten-API verfügt über ein Kontingent von Transaktionen pro Sekunde, bevor Anforderungen gedrosselt werden. Informationen zu dem Kontingent finden Sie unter [Kontingente für die Amazon-Redshift-Daten-API](amazon-redshift-limits.md#data-api-quotas-account). Wenn die Anforderungsrate das Kontingent überschreitet, wird eine `ThrottlingException` mit dem HTTP-Statuscode: 400 zurückgegeben. [https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html) In einigen Fällen wird diese Strategie bei Drosselungsfehlern automatisch implementiert. AWS SDKs
**Anmerkung**
Standardmäßig sind AWS Step Functions Wiederholungsversuche nicht aktiviert. Wenn Sie eine Redshift-Daten-API in einem Step-Functions-Zustandsautomat aufrufen müssen, fügen Sie den Idempotenzparameter `ClientToken` in Ihren Redshift-Daten-API-Aufruf ein. Der Wert für `ClientToken` muss auch bei Wiederholungsversuchen beibehalten werden. Im folgenden Beispielausschnitt einer Anforderung an die `ExecuteStatement`-API verwendet der Ausdruck `States.ArrayGetItem(States.StringSplit($$.Execution.Id, ':'), 7)` eine intrinsische Funktion, um den UUID-Teil von `$$.Execution.Id` zu extrahieren, der für jede Ausführung des Zustandsautomats eindeutig ist. Weitere Informationen finden Sie unter [Intrinsische Funktionen](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-intrinsic-functions.html) im *AWS Step Functions -Entwicklerhandbuch*.
```
{
"Database": "dev",
"Sql": "select 1;",
"ClusterIdentifier": "MyCluster",
"ClientToken.$": "States.ArrayGetItem(States.StringSplit($$.Execution.Id, ':'), 7)"
}
```
## Auswählen der Anmeldeinformationen für die Datenbankauthentifizierung beim Aufrufen der Amazon Redshift Data API
Wenn Sie die Data API aufrufen, verwenden Sie eine der folgenden Authentifizierungsmethoden für einige API-Vorgänge. Jede Methode erfordert eine andere Kombination von Parametern.
**AWS IAM Identity Center**
Der Zugriff auf die Data API kann durch einen Single-Sign-On-Benutzer erfolgen, der in AWS IAM Identity Center registriert ist. Weitere Informationen zu den Schritten zum Einrichten des IAM Identity Center finden Sie unter [Verwenden der Data API mit Weitergabe von vertrauenswürdigen Identitäten](data-api-trusted-identity-propagation.md).
**AWS Secrets Manager**
Geben Sie bei dieser Methode den Wert `secret-arn` eines Geheimnisses an AWS Secrets Manager , in dem `username` und `password` gespeichert ist. Das angegebene Secret enthält Anmeldeinformationen zum Verbinden mit der von Ihnen angegebenen `database`. Wenn Sie eine Verbindung zu einem Cluster herstellen, geben Sie auch den Datenbanknamen an. Wenn Sie eine Clusterkennung (`dbClusterIdentifier`) angeben, muss diese mit der in dem Secret gespeicherten Clusterkennung übereinstimmen. Wenn Sie eine Verbindung zu einer Serverless-Arbeitsgruppe herstellen, geben Sie auch den Datenbanknamen an. Weitere Informationen finden Sie unter [Speichern von Datenbankanmeldedaten in AWS Secrets Manager](data-api-secrets.md).
Mit dieser Methode können Sie auch einen `region` Wert angeben, der angibt, AWS-Region wo sich Ihre Daten befinden.
**Temporäre Anmeldeinformationen**
Wählen Sie bei dieser Methode eine der folgenden Optionen aus:
+ Wenn Sie eine Verbindung zu einer Serverless-Arbeitsgruppe herstellen, geben Sie den Arbeitsgruppennamen und den Datenbanknamen an. Der Datenbankbenutzername wird von der IAM-Identität abgeleitet. Für `arn:iam::123456789012:user:foo` lautet der Datenbankbenutzername beispielsweise `IAM:foo`. Auch die Berechtigung zum Aufruf der `redshift-serverless:GetCredentials`-Operation ist erforderlich.
+ Geben Sie die Clusterkennung und den Datenbanknamen an, wenn Sie eine Verbindung zu einem Cluster als IAM-Identität herstellen. Der Datenbankbenutzername wird von der IAM-Identität abgeleitet. Für `arn:iam::123456789012:user:foo` lautet der Datenbankbenutzername beispielsweise `IAM:foo`. Auch die Berechtigung zum Aufruf der `redshift:GetClusterCredentialsWithIAM`-Operation ist erforderlich.
+ Geben Sie die Clusterkennung, den Datenbanknamen und den Namen des Datenbankbenutzers an, wenn Sie eine Verbindung zu einem Cluster als Datenbankbenutzer herstellen. Auch die Berechtigung zum Aufruf der `redshift:GetClusterCredentials`-Operation ist erforderlich. Hinweise dazu, wie Sie Datenbankgruppen beitreten, wenn Sie mit dieser Methode eine Verbindung herstellen, finden Sie unter [Beitreten zu Datenbankgruppen beim Herstellen einer Verbindung mit einem Cluster](data-api-dbgroups.md).
Mit dieser Methode können Sie auch einen `region` Wert angeben, der angibt, AWS-Region wo sich Ihre Daten befinden.
## Zuordnen von JDBC-Datentypen beim Aufrufen der Amazon Redshift Data API
In der folgenden Tabelle sind den Datentypen, die Sie in Daten-API-Aufrufen angeben, JDBC-Datentypen (Java Database Connectivity) zugeordnet.
****
| JDBC-Datentyp | Daten-API-Datentyp |
| --- | --- |
| `INTEGER, SMALLINT, BIGINT` | `LONG` |
| `FLOAT, REAL, DOUBLE` | `DOUBLE` |
| `DECIMAL` | `STRING` |
| `BOOLEAN, BIT` | `BOOLEAN` |
| `BLOB, BINARY, LONGVARBINARY` | `BLOB` |
| `VARBINARY` | `STRING` |
| `CLOB` | `STRING` |
| Andere Typen (einschließlich datums- und zeitbezogener Typen) | `STRING` |
Zeichenfolgenwerte werden an die Amazon-Redshift-Datenbank übergeben und implizit in einen Datenbankdatentyp umgewandelt.
**Anmerkung**
Derzeit unterstützt die Daten-API keine Arrays mit universellen eindeutigen Identifikatoren ()UUIDs.
## Ausführen von SQL-Anweisungen mit Parametern beim Aufrufen der Amazon Redshift Data API
Sie können den an die Datenbank-Engine übermittelten SQL-Text kontrollieren, indem Sie den Data-API-Vorgang mithilfe von Parametern für Teile der SQL-Anweisung aufrufen. Benannte Parameter bieten eine flexible Möglichkeit, Parameter zu übergeben, ohne sie im SQL-Text hart zu codieren. Sie helfen Ihnen, SQL-Text wiederzuverwenden und SQL-Injections-Probleme zu vermeiden.
Das folgende Beispiel zeigt die benannten Parameter eines `parameters` Felds eines `execute-statement` AWS CLI Befehls.
```
--parameters "[{\"name\": \"id\", \"value\": \"1\"},{\"name\": \"address\", \"value\": \"Seattle\"}]"
```
Beachten Sie Folgendes, wenn Sie benannte Parameter verwenden:
+ Benannte Parameter können nur verwendet werden, um Werte in SQL-Anweisungen zu ersetzen.
+ Sie können die Werte in einer INSERT-Anweisung, wie z. B. `INSERT INTO mytable VALUES(:val1)`, ersetzen.
Die benannten Parameter können in beliebiger Reihenfolge vorliegen und Parameter können mehrmals im SQL-Text verwendet werden. Die in einem vorherigen Beispiel gezeigte Parameteroption, die Werte `1` und `Seattle` werden in die Tabellenspalten `id` und `address` eingefügt. Im SQL-Text geben Sie die benannten Parameter wie folgt an:
```
--sql "insert into mytable values (:id, :address)"
```
+ Sie können die Werte in einer Bedingungsklausel ersetzen, z. B. `WHERE attr >= :val1`, `WHERE attr BETWEEN :val1 AND :val2` und `HAVING COUNT(attr) > :val`.
+ Sie können in einer SQL-Anweisung keine Spaltennamen ersetzen, wie z. B. `SELECT column-name`, `ORDER BY column-name` oder `GROUP BY column-name`.
Die folgende SELECT-Anweisung schlägt beispielsweise aufgrund bei einer ungültigen Syntax fehl.
```
--sql "SELECT :colname, FROM event" --parameters "[{\"name\": \"colname\", \"value\": \"eventname\"}]"
```
Wenn Sie die Anweisung mit dem Syntaxfehler beschreiben (`describe-statement`-Operation), ersetzt der zurückgegebene `QueryString` nicht den Spaltennamen für den Parameter (`"QueryString": "SELECT :colname, FROM event"`) und es wird ein Fehler gemeldet (ERROR: Syntaxfehler bei oder nahe \$1"FROM\$1"\$1n Position: 12).
+ Sie können in einer Aggregatfunktion keine Spaltennamen ersetzen, wie z. B. `COUNT(column-name)`, `AVG(column-name)` oder `SUM(column-name)`.
+ Sie können Spaltennamen in einer JOIN-Klausel nicht ersetzen.
+ Wenn die SQL-Anweisung ausgeführt wird, werden Daten implizit in einen Datentyp umgewandelt. Weitere Informationen zur Datentypumwandlung finden Sie unter [Datentypen](https://docs.aws.amazon.com/redshift/latest/dg/c_Supported_data_types.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
+ Sie können einen Wert nicht auf NULL setzen. Die Data API interpretiert ihn als Literalzeichenfolge `NULL`. Im folgenden Beispiel wird `id` durch die Literalzeichenfolge `null` ersetzt, nicht durch den SQL-NULL-Wert.
```
--parameters "[{\"name\": \"id\", \"value\": \"null\"}]"
```
+ Sie können keinen Wert mit Länge null festlegen. Die SQL-Anweisung der Data API schlägt fehl. Im folgenden Beispiel wird versucht, `id` mit einem Wert der Länge null festzulegen, was zum Fehlschlagen der SQL-Anweisung führt.
```
--parameters "[{\"name\": \"id\", \"value\": \"\"}]"
```
+ Sie können einen Tabellennamen in der SQL-Anweisung nicht mit einem Parameter festlegen. Die Data API folgt der Regel des JDBC-`PreparedStatement`.
+ Die Ausgabe der Operation `describe-statement` gibt die Abfrageparameter einer SQL-Anweisung zurück.
+ Nur der `execute-statement`-Vorgang unterstützt SQL-Anweisungen mit Parametern.
## Ausführen von SQL-Anweisungen mit einem Idempotenz-Token beim Aufrufen der Amazon Redshift Data API
Wenn Sie eine ändernde API-Anfrage stellen, gibt die Anfrage in der Regel ein Ergebnis zurück, bevor die asynchronen Workflows der Operation abgeschlossen sind. Es können auch ein Timeout oder andere Serverprobleme auftreten, bevor Operationen abgeschlossen sind, obwohl die Anfrage bereits ein Ergebnis zurückgegeben hat. Dadurch lässt sich möglicherweise nur schwer feststellen, ob die Anfrage erfolgreich war oder nicht, und es werden möglicherweise mehrere Wiederholungsversuche vorgenommen, um sicherzustellen, dass die Operation erfolgreich abgeschlossen wird. Wenn die ursprüngliche Anfrage und die nachfolgenden Wiederholungsversuche jedoch erfolgreich sind, wird die Operation mehrmals abgeschlossen. Das bedeutet, dass Sie möglicherweise mehr Ressourcen aktualisieren als beabsichtigt.
*Idempotenz* stellt sicher, dass eine API-Anfrage nicht mehr als einmal abgeschlossen wird. Wenn bei einer idempotenten Anfrage die ursprüngliche Anfrage erfolgreich abgeschlossen wird, werden alle nachfolgenden Wiederholungen erfolgreich abgeschlossen, ohne dass weitere Aktionen ausgeführt werden. Die Data-API-Operationen `ExecuteStatement` und `BatchExecuteStatement` weisen den optionalen idempotenten Parameter `ClientToken` auf. Das `ClientToken` läuft nach 8 Stunden ab.
**Wichtig**
Wenn Sie von einem AWS SDK aus aufrufen `ExecuteStatement` und `BatchExecuteStatement` Operationen ausführen, generiert es automatisch ein Client-Token, das bei einem erneuten Versuch verwendet wird. In diesem Fall empfehlen wir, den Parameter `client-token` nicht mit den Operationen `ExecuteStatement` und `BatchExecuteStatement` zu verwenden. Sehen Sie CloudTrail sich das Protokoll an, um das `ClientToken` zu sehen. Ein Beispiel für ein CloudTrail Protokoll finden Sie unter[Amazon-Redshift-Daten-API – Beispiele](logging-with-cloudtrail.md#data-api-cloudtrail).
Der folgende `execute-statement` AWS CLI Befehl veranschaulicht den optionalen `client-token` Parameter für Idempotenz.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
--client-token b855dced-259b-444c-bc7b-d3e8e33f94g1
```
Die folgende Tabelle zeigt einige häufig vorkommende Antworten, die Sie auf idempotente API-Anfragen erhalten könnten, und stellt Empfehlungen zu Wiederholungsversuchen bereit.
| Antwort | Empfehlung | Kommentare |
| --- | --- | --- |
| 200 (OK) | Nicht erneut versuchen | Die ursprüngliche Anfrage wurde erfolgreich abgeschlossen. Alle nachfolgenden Wiederholungsversuche werden als erfolgreich zurückgegeben. |
| Antwortcodes der Serie 400 | Nicht erneut versuchen | Es liegt eins der folgenden Probleme mit der Anfrage vor: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/mgmt/data-api.html) Wenn die Anfrage eine Ressource umfasst, deren Status sich gerade ändert, könnte ein erneuter Anfrageversuch möglicherweise erfolgreich sein. |
| Antwortcodes der Serie 500 | Erneut versuchen | Der Fehler wird durch ein AWS serverseitiges Problem verursacht und ist im Allgemeinen vorübergehend. Wiederholen Sie die Anfrage mit einer geeigneten Backoff-Strategie. |
Weitere Informationen zu den Amazon-Redshift-Antwortcodes finden Sie unter [Häufige Fehler](https://docs.aws.amazon.com/redshift/latest/APIReference/CommonErrors.html) in der *API-Referenz zu Amazon Redshift*.
## Ausführen von SQL-Anweisungen mit Sitzungswiederverwendung beim Aufrufen der Amazon Redshift Data API
Wenn Sie eine API-Anfrage zur Ausführung einer SQL-Anweisung stellen, wird die Sitzung, in der das SQL ausgeführt wird, normalerweise beendet, wenn die SQL-Anweisung beendet ist. Um die Sitzung für eine bestimmte Anzahl von Sekunden aktiv zu halten, verfügen die Data-API-Operationen `ExecuteStatement` und `BatchExecuteStatement` über einen optionalen Parameter `SessionKeepAliveSeconds`. In einem `SessionId`-Antwortfeld ist die Identität der Sitzung angegeben, die dann in nachfolgenden `ExecuteStatement`- und `BatchExecuteStatement`-Operationen verwendet werden kann. Bei nachfolgenden Aufrufen können Sie einen anderen `SessionKeepAliveSeconds`-Wert angeben, um die Leerlaufzeitüberschreitung zu ändern. Wenn `SessionKeepAliveSeconds` nicht geändert wird, bleibt die ursprüngliche Einstellung für die Leerlaufzeitüberschreitung bestehen. Beachten Sie Folgendes, wenn Sie die Sitzungswiederverwendung nutzen:
+ Der maximal zulässige Wert für `SessionKeepAliveSeconds` beträgt 24 Stunden.
+ Die Sitzung kann höchstens 24 Stunden dauern. Nach 24 Stunden wird die Schließung der Sitzung erzwungen und laufende Abfragen werden beendet.
+ Die maximale Anzahl von Sitzungen pro Amazon-Redshift-Cluster oder Redshift-Serverless-Arbeitsgruppe beträgt 500.
+ Sie können jeweils nur eine Abfrage in einer Sitzung ausführen. Sie müssen warten, bis die Abfrage abgeschlossen ist, um die nächste Abfrage in derselben Sitzung auszuführen. Sie können also Abfragen in einer bereitgestellten Sitzung nicht parallel ausführen.
+ Die Data API kann Abfragen für eine bestimmte Sitzung nicht in die Warteschlange stellen.
Um die `SessionId` abzurufen, die von Aufrufen der Operationen `ExecuteStatement` und `BatchExecuteStatement` verwendet wird, rufen Sie die Operationen `DescribeStatement` und `ListStatements` auf.
Das folgende Beispiel zeigt, wie die Parameter `SessionKeepAliveSeconds` und `SessionId` verwendet werden, um eine Sitzung aufrechtzuerhalten und wiederzuverwenden. Rufen Sie zunächst den `execute-statement` AWS CLI Befehl auf, wobei der optionale `session-keep-alive-seconds` Parameter auf gesetzt ist. `2`
```
aws redshift-data execute-statement
--session-keep-alive-seconds 2
--sql "select 1"
--database dev
--workgroup-name mywg
```
Die Antwort enthält die Sitzungs-ID.
```
{
"WorkgroupName": "mywg",
"CreatedAt": 1703022996.436,
"Database": "dev",
"DbUser": "awsuser",
"Id": "07c5ffea-76d6-4786-b62c-4fe3ef529680",
"SessionId": "5a254dc6-4fc2-4203-87a8-551155432ee4"
}
```
Rufen Sie dann den `execute-statement` AWS CLI Befehl mit dem vom ersten Aufruf `SessionId` zurückgegebenen Befehl auf. Geben Sie optional den Parameter `session-keep-alive-seconds`, der auf `10` gesetzt ist, an, um den Wert für die Leerlaufzeitüberschreitung zu ändern.
```
aws redshift-data execute-statement
--sql "select 1"
--session-id 5a254dc6-4fc2-4203-87a8-551155432ee4
--session-keep-alive-seconds 10
```
## Abrufen von Ergebnissen von SQL-Anweisungen
Je nach Ergebnisformat verwenden Sie unterschiedliche Daten-API-Operationen, um SQL-Ergebnisse abzurufen. Wenn Sie `ExecuteStatement`- und `BatchExecuteStatement`-Operationen aufrufen, können Sie angeben, ob die Ergebnisse als JSON oder CSV formatiert sein sollen. Wenn Sie nichts angeben, ist der Standardwert JSON. Verwenden Sie die Operation `GetStatementResult`, um JSON-Ergebnisse abzurufen. Verwenden Sie die Operation `GetStatementResultV2`, um CSV-Ergebnisse abzurufen.
Bei den im JSON-Format zurückgegebenen Ergebnissen handelt es sich um Datensätze, die Metadaten zu jeder Spalte enthalten. Jeder Datensatz liegt im JSON-Format vor. Die Antwort von `GetStatementResult` sieht beispielsweise ungefähr folgendermaßen aus:
```
{
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "?column?",
"name": "?column?",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "",
"typeName": "int4",
"length": 0
}
],
"NextToken": "",
"Records": [
[
{
"longValue": 1
}
]
],
"TotalNumRows":
}
```
Bei den im CSV-Format zurückgegebenen Ergebnissen handelt es sich um Datensätze, die Metadaten zu jeder Spalte enthalten. Die Ergebnisse werden in 1-MB-Blöcken zurückgegeben, wobei in jedem Block eine beliebige Anzahl von Zeilen im CSV-Format gespeichert werden kann. Jede Anfrage gibt bis zu 15 MB an Ergebnissen zurück. Wenn die Ergebnisse mehr als 15 MB umfassen, wird ein Token für die nächste Seite zurückgegeben, um mit dem Abrufen der Ergebnisse fortzufahren. Die Antwort von `GetStatementResultV2` sieht beispielsweise ungefähr folgendermaßen aus:
```
{
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "?column?",
"name": "?column?",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "?column?",
"name": "?column?",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "?column?",
"name": "?column?",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "",
"typeName": "int4",
"length": 0
}
],
"NextToken": "",
"Records": [
[
{
"CSVRecords":"1,2,3\r\n4,5,6\r\n7,8,9\rn, .... 1MB" // First 1MB Chunk
},
{
"CSVRecords":"1025,1026,1027\r\n1028,1029,1030\r\n....2MB" // Second 1MB chunk
}
...
]
],
"ResultFormat" : "CSV",
"TotalNumRows":
}
```
# Autorisieren des Zugriffs auf die Amazon Redshift Data API
Ein Benutzer muss zum Zugriff auf die Data API autorisiert sein. Sie können einen Benutzer zum Zugriff auf die Data API autorisieren, indem Sie dem betreffenden Benutzer eine verwaltete Richtlinie, eine vordefinierte AWS Identity and Access Management (IAM)-Richtlinie, hinzufügen. Als bewährte Methode empfehlen wir, einer IAM-Rolle Berechtigungsrichtlinien anzufügen und sie dann nach Bedarf Benutzern und Gruppen zuzuweisen. Weitere Informationen finden Sie unter [Identity and Access Management in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-authentication-access-control.html). In der IAM-Konsole ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) finden Sie Informationen zu den Berechtigungen, die durch verwaltete Richtlinien zugelassen und verweigert wurden.
# Konfigurieren von IAM-Berechtigungen
Amazon Redshift stellt die von `AmazonRedshiftDataFullAccess` verwaltete Richtlinie bereit. Diese Richtlinie bietet vollständigen Zugriff auf die Amazon-Redshift-Data-API-Vorgänge. Diese Richtlinie ermöglicht auch den bereichsbezogenen Zugriff auf bestimmte Amazon Redshift- und IAM-API-Operationen AWS Secrets Manager, die für die Authentifizierung und den Zugriff auf einen Amazon Redshift Redshift-Cluster oder eine Redshift Serverless-Arbeitsgruppe erforderlich sind.
Sie können auch eine eigene IAM-Richtlinie erstellen, die den Zugriff auf bestimmte Ressourcen ermöglicht. Um Ihre Richtlinie zu erstellen, verwenden Sie die `AmazonRedshiftDataFullAccess`-Richtlinie als Ausgangspunkt. Nach dem Erstellen Ihrer Richtlinie können Sie diese jedem Benutzer hinzufügen, der Zugriff auf die Data API benötigt.
Berücksichtigen Sie die folgenden Anforderungen der IAM-Richtlinie, die mit dem Benutzer verknüpft ist:
+ Wenn Sie die Authentifizierung verwenden, vergewissern Sie AWS Secrets Manager sich, dass die Richtlinie die Verwendung der Aktion zum Abrufen des mit dem Schlüssel markierten Geheimnisses `secretsmanager:GetSecretValue` zulässt. `RedshiftDataFullAccess`
+ Wenn Sie temporäre Anmeldeinformationen für die Authentifizierung verwenden, prüfen Sie, ob die Richtlinie die Verwendung der `redshift:GetClusterCredentials`-Aktion für den Datenbankbenutzernamen `redshift_data_api_user` für jede Datenbank im Cluster erlaubt. Dieser Benutzername muss bereits in Ihrer Datenbank erstellt worden sein.
+ Wenn Sie temporäre Anmeldeinformationen verwenden, um sich bei einer Serverless-Arbeitsgruppe zu authentifizieren, bestätigen Sie, dass die Richtlinie die Verwendung der Aktion `redshift-serverless:GetCredentials` zum Abrufen der mit dem Schlüssel `RedshiftDataFullAccess` gekennzeichneten Arbeitsgruppe zulässt. Der Datenbankbenutzer wird der Quellidentität AWS Identity and Access Management (IAM) 1:1 zugeordnet. Der Benutzer sample\$1user ist beispielsweise einem Datenbankbenutzer `IAM:sample_user` und die IAM-Rolle sample\$1role ist `IAMR:sample_role` zugeordnet. Weitere Informationen zu unterschiedlichen IAM-Identitäten finden Sie unter [IAM-Identitäten (Benutzer, Benutzergruppen und Rollen)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) im IAM-Benutzerhandbuch.
+ Die IAM-Aktion `redshift-data:GetStatementResult` ermöglicht den Zugriff auf die API-Operationen `GetStatementResult` und `GetStatementResultV2`.
Unter den folgenden Links finden Sie weitere Informationen zum AWS Identity and Access Management *IAM-Benutzerhandbuch*.
+ Weitere Informationen zum Erstellen von IAM-Rollen finden Sie unter [Erstellen von IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).
+ Informationen zum Erstellen einer IAM-Richtlinie finden Sie unter [Erstellen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
+ Informationen zum Hinzufügen einer IAM-Richtlinie zu einem Benutzer finden Sie unter [Hinzufügen und Entfernen von IAM-Identitätsberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
## Ausführen einer Abfrage auf einem Cluster, der einem anderen Konto gehört
Um eine Abfrage in einem Cluster auszuführen, der einem anderen Konto gehört, muss das besitzende Konto eine IAM-Rolle bereitstellen, die die Data API im aufrufenden Konto übernehmen kann. Angenommen, Konto B besitzt einen Cluster, auf den Konto A zugreifen muss. Konto B kann die AWS verwaltete Richtlinie `AmazonRedshiftDataFullAccess` der IAM-Rolle von Konto B zuordnen. Dann vertraut Konto B Konto A mit einer Vertrauensrichtlinie wie der folgenden: ``
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/someRoleA"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Schließlich muss die IAM-Rolle von Konto A die IAM-Rolle von Konto B übernehmen können.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/someRoleB"
}
}
```
------
## Geben Sie eine IAM-Rolle an, die Ressourcen auf Redshift Serverless-Arbeitsgruppen und Amazon Redshift Redshift-Cluster in einem beschränkt AWS-Konto
Sie können ARNs in Ihrer identitätsbasierten Richtlinie eine Ressource angeben, um den Zugriff auf Redshift Serverless-Arbeitsgruppen und Amazon Redshift Redshift-Cluster in einem zu kontrollieren. AWS-Konto In diesem Beispiel wird gezeigt, wie Sie eine Richtlinie erstellen können, die den Zugriff auf die Data API nur für die Arbeitsgruppe und die Cluster in dem angegebenen AWS-Konto ermöglicht.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"redshift-data:CancelStatement",
"redshift-data:DescribeStatement",
"redshift-data:GetStatementResult",
"redshift-data:ListStatements"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "redshift-data:*",
"Resource": [
"arn:aws:redshift:us-east-1:111122223333:workgroup/*",
"arn:aws:redshift:us-east-1:111122223333:cluster:*"
]
}
]
}
```
------
## Konfigurieren Sie eine IAM-Richtlinie, die den Zugriff auf SQL-Anweisungsinformationen auf den Eigentümer der Anweisung beschränkt
Standardmäßig behandelt die Amazon Redshift Data API die IAM-Rolle, die beim Aufrufen von `ExecuteStatement` und `BatchExecuteStatement` verwendet wird, als Eigentümer der SQL-Anweisung. Jeder, der die Rolle übernehmen darf, kann auf Informationen über die SQL-Anweisung zugreifen, einschließlich ihrer Ergebnisse. Um den Zugriff auf Informationen zu SQL-Anweisungen auf eine IAM-Rollensitzung mit einem bestimmten Eigentümer zu beschränken, fügen Sie eine Bedingung `redshift-data:statement-owner-iam-userid: "${aws:userid}"` hinzu. Die folgende IAM-Richtlinie beschränkt den Zugriff.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"redshift-data:CancelStatement",
"redshift-data:DescribeStatement",
"redshift-data:GetStatementResult",
"redshift-data:ListStatements"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"redshift-data:statement-owner-iam-userid": "${aws:userid}"
}
}
}
]
}
```
------
Sie können die Bedingung `statement-owner-iam-userid` mit `CancelStatement`, `DescribeStatement`, `GetStatementResult` und `ListStatements` verwenden. Weitere Informationen finden Sie unter [Actions defined by Amazon Redshift Data API](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonredshiftdataapi.html#amazonredshiftdataapi-redshift-data_statement-owner-iam-userid).
## Konfigurieren Sie eine IAM-Richtlinie, die den Zugriff auf SQL-Ergebnisse auf den Sitzungseigentümer beschränkt
Standardmäßig behandelt die Amazon Redshift Data API die IAM-Rolle, die beim Aufrufen von `ExecuteStatement` und `BatchExecuteStatement` verwendet wird, als Eigentümer der Datenbanksitzung, in der die SQL-Anweisung ausgeführt wird. Jeder, der berechtigt ist, die Rolle anzunehmen, kann Abfragen an die Datenbanksitzung stellen. Um den Sitzungszugriff auf eine IAM-Rollensitzung mit einem bestimmten Eigentümer zu beschränken, fügen Sie eine Bedingung ` redshift-data:session-owner-iam-userid: "${aws:userid}"` hinzu. Die folgende IAM-Richtlinie beschränkt den Zugriff.
Die folgende IAM-Richtlinie ermöglicht es nur dem Sitzungseigentümer, Anweisungsergebnisse abzurufen. Die Bedingung `session-owner-iam-userid` wird verwendet, um den Ressourcenzugriff auf die angegebene `userid` zu beschränken.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"redshift-data:ExecuteStatement",
"redshift-data:BatchExecuteStatement"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"redshift-data:session-owner-iam-userid": "${aws:userid}"
}
}
}
]
}
```
------
Sie können die Bedingung `session-owner-iam-userid` mit `ExecuteStatement` und `BatchExecuteStatement` verwenden. Weitere Informationen finden Sie unter [Actions defined by Amazon Redshift Data API](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonredshiftdataapi.html#amazonredshiftdataapi-redshift-data_statement-owner-iam-userid).
# Speichern von Datenbankanmeldedaten in AWS Secrets Manager
Wenn Sie die Data API aufrufen, können Sie die Anmeldeinformationen für den Cluster oder die Serverless-Arbeitsgruppe unter Verwendung eines Secrets in AWS Secrets Managerübergeben. Zum Übermitteln der Anmeldeinformationen auf diese Weise geben Sie den Namen des Secrets oder den Amazon-Ressourcennamen (ARN) des Secrets an.
Um Anmeldeinformationen mit Secrets Manager zu speichern, benötigen Sie eine von `SecretManagerReadWrite` verwaltete Richtlinienberechtigung. Weitere Informationen zu den Mindestberechtigungen finden Sie unter [Creating and Managing AWS Secrets with Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/managing-secrets.html) im *AWS Secrets Manager Benutzerhandbuch*.
**So speichern Sie Ihre Anmeldeinformationen in einem Secret für einen Amazon-Redshift-Cluster**
1. Verwenden Sie die AWS Secrets Manager Konsole, um einen geheimen Schlüssel zu erstellen, der Anmeldeinformationen für Ihren Cluster enthält:
+ Wenn Sie **Store a new secret** (Neues Secret speichern) auswählen, wählen Sie **Credentials for Redshift cluster** (Anmeldeinformationen für Redshift-Cluster) aus.
+ Speichern Sie Ihre Werte für **User name (Benutzername)** (Datenbankbenutzer),**Password (Passwort)** und **DB cluster (DB-Cluster)** (Cluster-ID) in Ihrem Secret.
+ Markieren Sie das Secret mit dem Schlüssel `RedshiftDataFullAccess`. Die AWS verwaltete Richtlinie erlaubt die Aktion `AmazonRedshiftDataFullAccess` nur `secretsmanager:GetSecretValue` für Geheimnisse, die mit dem Schlüssel gekennzeichnet sind`RedshiftDataFullAccess`.
Anweisungen finden Sie unter [Erstellen eines Basis-Secrets](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) im *AWS Secrets Manager -Benutzerhandbuch*.
1. Verwenden Sie die AWS Secrets Manager Konsole, um die Details für das von Ihnen erstellte Geheimnis anzuzeigen, oder führen Sie den `aws secretsmanager describe-secret` AWS CLI Befehl aus.
Notieren Sie sich den Namen und den ARN des Secrets. Sie können diese in Aufrufen an die Data API verwenden.
**So speichern Sie Ihre Anmeldeinformationen in einem Secret für eine Serverless-Arbeitsgruppe**
1. Verwenden Sie AWS Secrets Manager AWS CLI Befehle, um ein Geheimnis zu speichern, das Anmeldeinformationen für Ihre serverlose Arbeitsgruppe enthält:
+ Erstellen Sie Ihr Secret in einer Datei, zum Beispiel einer JSON-Datei mit dem Namen `mycreds.json`. Geben Sie die Werte für **User name** (Benutzername) (d. h. den Namen des Datenbankbenutzers) und **Password** (Kennwort) in der Datei an.
```
{
"username": "myusername",
"password": "mypassword"
}
```
+ Speichern Sie Ihre Werte in Ihrem Secret und markieren Sie das Secret mit dem Schlüssel `RedshiftDataFullAccess`.
```
aws secretsmanager create-secret --name MyRedshiftSecret --tags Key="RedshiftDataFullAccess",Value="serverless" --secret-string file://mycreds.json
```
Nachfolgend sehen Sie die Ausgabe.
```
{
"ARN": "arn:aws:secretsmanager:region:accountId:secret:MyRedshiftSecret-mvLHxf",
"Name": "MyRedshiftSecret",
"VersionId": "a1603925-e8ea-4739-9ae9-e509eEXAMPLE"
}
```
Weitere Informationen finden Sie unter [Erstellen eines Basis-Secrets mit der AWS CLI](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html#proc-create-api) im *AWS Secrets Manager -Benutzerhandbuch*.
1. Verwenden Sie die AWS Secrets Manager Konsole, um die Details für das von Ihnen erstellte Geheimnis anzuzeigen, oder führen Sie den `aws secretsmanager describe-secret` AWS CLI Befehl aus.
Notieren Sie sich den Namen und den ARN des Secrets. Sie können diese in Aufrufen an die Data API verwenden.
# Erstellen eines Amazon-VPC-Endpunkts (AWS PrivateLink) für die Data API
Mit Amazon Virtual Private Cloud (Amazon VPC) können Sie AWS Ressourcen wie Amazon Redshift Redshift-Cluster und -Anwendungen in einer Virtual Private Cloud (VPC) starten. AWS PrivateLink bietet private Konnektivität zwischen virtuellen privaten Clouds (VPCs) und sicheren AWS Diensten im Amazon-Netzwerk. Mithilfe AWS PrivateLink können Sie VPC-Endpunkte erstellen, mit denen Sie Verbindungen zu Diensten herstellen können, die über verschiedene Konten hinweg und auf Amazon VPC VPCs basieren. Weitere Informationen AWS PrivateLink finden Sie unter [VPC Endpoint Services (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-service.html) im *Amazon Virtual Private Cloud Cloud-Benutzerhandbuch*.
Sie können die Daten-API mit Amazon VPC-Endpunkten aufrufen. Die Verwendung eines Amazon-VPC-Endpunkts hält den Datenverkehr zwischen Anwendungen in Ihrer Amazon VPC und der Data API im AWS -Netzwerk aufrecht, ohne öffentliche IP-Adressen zu verwenden. Amazon-VPC-Endpunkte können Ihnen dabei helfen, Compliance- und behördliche Anforderungen im Zusammenhang mit der Einschränkung der öffentlichen Internetkonnektivität zu erfüllen. Wenn Sie beispielsweise einen Amazon VPC-Endpunkt verwenden, können Sie den Verkehr zwischen einer Anwendung, die auf einer Amazon EC2 EC2-Instance ausgeführt wird, und der Daten-API in der VPCs , die sie enthält, aufrechterhalten.
Nachdem Sie den Amazon VPC-Endpunkt erstellt haben, können Sie ihn verwenden, ohne Code- oder Konfigurationsänderungen in der Anwendung vorzunehmen.
**So erstellen Sie einen Amazon VPC-Endpunkt für die Daten-API**
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 **Endpunkte** und dann **Endpunkt erstellen** aus.
1. Wählen Sie auf der Seite **Create Endpoint (Endpunkt erstellen)** für **Service category (Servicekategorie)** die Option **AWS -Services** aus. Wählen Sie bei **Service Name** **redshift-data** (`com.amazonaws.region.redshift-data`) aus.
1. Wählen Sie für **VPC** die VPC aus, in der der Endpunkt erstellt werden soll.
Wählen Sie die VPC aus, die die Anwendung enthält, die Daten-API-Aufrufe ausführt.
1. Wählen Sie für **Subnetze** das Subnetz für jede Availability Zone (AZ) aus, die von dem AWS Service verwendet wird, auf dem Ihre Anwendung ausgeführt wird.
Um einen Amazon-VPC-Endpunkt zu erstellen, geben Sie den privaten IP-Adressbereich an, in dem der Endpunkt zugänglich ist. Wählen Sie dazu das Subnetz für jede Availability Zone aus. Dadurch wird der VPC-Endpunkt auf den privaten IP-Adressbereich beschränkt, der für jede Availability Zone spezifisch ist. Außerdem wird in jeder Availability Zone ein Amazon VPC-Endpunkt erstellt.
1. Wählen Sie für **DNS-Namen aktivieren** die Option **Für diesen Endpunkt aktivieren** aus.
Private DNS löst den standardmäßigen DNS-Hostnamen der Daten-API (`https://redshift-data.region.amazonaws.com`) in die privaten IP-Adressen auf, die mit dem für Ihren Amazon VPC-Endpunkt spezifischen DNS-Hostnamen verknüpft sind. Daher können Sie mit oder auf den Daten-API-VPC-Endpunkt zugreifen, AWS SDKs ohne Code AWS CLI - oder Konfigurationsänderungen vorzunehmen, um die Daten-API-Endpunkt-URL zu aktualisieren.
1. Wählen Sie für **Sicherheitsgruppe** eine Sicherheitsgruppe aus, die dem Amazon VPC-Endpunkt zugeordnet werden soll.
Wählen Sie die Sicherheitsgruppe aus, die den Zugriff auf den AWS Dienst ermöglicht, auf dem Ihre Anwendung ausgeführt wird. Wenn beispielsweise eine Amazon EC2-Instance Ihre Anwendung ausführt, wählen Sie die Sicherheitsgruppe aus, die den Zugriff auf die Amazon EC2-Instance ermöglicht. Mit der Sicherheitsgruppe können Sie den Datenverkehr zum Amazon VPC-Endpunkt von Ressourcen in Ihrer VPC steuern.
1. Wählen Sie **Create endpoint**.
Nachdem der Endpunkt erstellt wurde, wählen Sie den Link in, AWS-Managementkonsole um die Endpunktdetails anzuzeigen.
Auf der Registerkarte **Details** des Endpunkts werden die DNS-Hostnamen angezeigt, die beim Erstellen des Amazon VPC-Endpunkts generiert wurden.
Sie können den Standardendpunkt (`redshift-data.region.amazonaws.com`) oder einen der VPC-spezifischen Endpunkte verwenden, um die Daten-API innerhalb der Amazon VPC aufzurufen. Der standardmäßige Daten-API-Endpunkt leitet automatisch an den Amazon VPC-Endpunkt weiter. Dieses Routing tritt auf, weil der private DNS-Hostname beim Erstellen des Amazon VPC-Endpunkts aktiviert wurde.
Wenn Sie einen Amazon VPC-Endpunkt in einem Daten-API-Aufruf verwenden, verbleibt der gesamte Datenverkehr zwischen Ihrer Anwendung und der Daten-API in dem Amazon VPCs , der sie enthält. Sie können einen Amazon VPC-Endpunkt für jeden Typ von Daten-API-Aufruf verwenden. Informationen zum Aufrufen der Daten-API finden Sie unter [Wichtige Punkte beim Aufrufen der Amazon Redshift Data API](data-api.md#data-api-calling-considerations).
# Beitreten zu Datenbankgruppen beim Herstellen einer Verbindung mit einem Cluster
Datenbankgruppen sind Sammlungen von Datenbankbenutzern. Datenbankberechtigungen können Gruppen gewährt werden. Ein Administrator kann eine IAM-Rolle so konfigurieren, dass diese Datenbankgruppen berücksichtigt werden, wenn Ihr SQL mit der Daten-API ausgeführt wird. Weitere Informationen über Datenbankgruppen finden Sie unter [Gruppen](https://docs.aws.amazon.com/redshift/latest/dg/r_Groups.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
Sie können die IAM-Rolle eines Daten-API-Aufrufers so konfigurieren, dass der im Aufruf angegebene Datenbankbenutzer Datenbankgruppen beitritt, wenn die Daten-API eine Verbindung mit einem Cluster herstellt. Diese Funktion wird nur unterstützt, wenn eine Verbindung mit bereitgestellten Clustern hergestellt wird. Sie wird nicht unterstützt beim Herstellen einer Verbindung mit Redshift-Serverless-Arbeitsgruppen. Die IAM-Rolle des Aufrufers der Daten-API muss außerdem die Aktion `redshift:JoinGroup` zulassen.
Konfigurieren Sie dies, indem Sie IAM-Rollen Tags hinzufügen. Der Administrator der IAM-Rolle des Aufrufers fügt Tags mit dem Schlüssel `RedshiftDbGroups` und einem Schlüsselwert einer Liste von Datenbankgruppen. Der Wert ist eine Liste von durch Doppelpunkt (:) getrennten Namen von Datenbankgruppen mit einer Gesamtlänge von bis zu 256 Zeichen. Die Datenbankgruppen müssen zuvor in der verbundenen Datenbank definiert worden sein. Wenn eine angegebene Gruppe in der Datenbank nicht zu finden ist, wird sie ignoriert. Zum Beispiel lautet der Schlüsselwert für die Datenbankgruppen `accounting` und `retail` `accounting:retail`. Das Tag-Schlüssel-Wert-Paar `{"Key":"RedshiftDbGroups","Value":"accounting:retail"}` wird von der Daten-API verwendet, um zu ermitteln, welche Datenbankgruppen dem angegebenen Datenbankbenutzer beim Aufruf der Daten-API zugeordnet sind.
**So treten Sie Datenbankgruppen bei**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Wählen Sie im Navigationsbereich der Konsole **Rollen** aus und wählen Sie dann den Namen der Rolle aus, die Sie bearbeiten möchten.
1. Wählen Sie die Registerkarte **Tags** und dann **Tags verwalten** aus.
1. Wählen Sie **Tag hinzufügen** und fügen Sie dann den Schlüssel **RedshiftDbGroups**und einen Wert hinzu, der eine Liste von *database-groups-colon-separated* ist.
1. Wählen Sie **Änderungen speichern ** aus.
Wenn nun ein IAM-Prinzipal (mit angefügter IAM-Rolle) die Daten-API aufruft, tritt der angegebene Datenbankbenutzer den in der IAM-Rolle angegebenen Datenbankgruppen bei.
Weitere Informationen darüber, wie Sie ein Tag an einen Prinzipal anhängen, einschließlich IAM-Rollen und IAM-Benutzern, finden Sie unter [Markieren von IAM-Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) im *IAM-Benutzerhandbuch*.
# Verwenden der Data API mit Weitergabe von vertrauenswürdigen Identitäten
Als Amazon Redshift-Kontoadministrator können Sie Ihren Amazon Redshift Redshift-Cluster oder Ihre Arbeitsgruppe in integrieren AWS IAM Identity Center, was Ihnen hilft, den Zugriff Ihrer Mitarbeiter auf Amazon Redshift mit Single Sign-On zu verwalten. Weitere Informationen finden Sie unter [Einrichtung der AWS IAM Identity Center-Integration mit Amazon Redshift](redshift-iam-access-control-idp-connect-console.md). Die Amazon Redshift Data API unterstützt die Weitergabe von IAM Identity Center-Benutzeridentitäten an einen Amazon Redshift Redshift-Cluster oder eine Arbeitsgruppe und an andere Dienste, z. B. in der Kette. AWS Lake Formation Sie können die Daten-API einrichten und Abfragen durchführen, indem Sie die Schritte unter [Access AWS Services](https://aws.amazon.com/blogs//security/access-aws-services-programmatically-using-trusted-identity-propagation/) programmgesteuert mithilfe von Trusted Identity Propagation befolgen.
Wenn Sie die Data API mithilfe einer IAM-Identity-Center-Benutzeridentität aus einer IAM-Rollensitzung mit verbesserter Identität aufrufen, können Sie nur mit demselben IAM-Identity-Center-Benutzer auf die resultierende Anweisung und das Ergebnis der Anweisung zugreifen. Mit dem folgenden AWS CLI Befehl wird beispielsweise der `execute-statement` Vorgang aufgerufen, um einen SQL-Befehl mit vertrauenswürdiger Identitätsverbreitung auszuführen.
```
aws redshift-data execute-statement
--sql "select current_user;"
--cluster-id mycluster
--database dev
```
Der folgende AWS CLI Befehl ruft die `batch-execute-statement` Operation zur Ausführung von zwei SQL-Befehlen auf.
```
aws redshift-data batch-execute-statement
--sqls "select current_user;" "select current_date;"
--cluster-id mycluster
--database dev
```
Für den Zugriff auf Anweisungen mit `cancel-statement`, `describe-statement`, `get-statement-result` und `get-statement-result-v2`, die über IAM-Rollensitzungen mit verbesserter Identität übermittelt wurden, müssen der IAM-Identity-Center-Benutzer und die IAM-Rolle mit den Anmeldeinformationen übereinstimmen, die für die Ausführung von `execute-statment` oder `batch-execute-statement` verwendet wurden. Mit dem folgenden AWS CLI Befehl werden beispielsweise die Ergebnisse einer SQL-Anweisung abgerufen.
```
aws redshift-data get-statement-result
--id a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
```
Um Anweisungen aufzulisten, muss ein Parameter `cluster-identifier` oder `workgroup-name` angegeben werden, um sicherzustellen, dass der IAM-Identity-Center-Benutzer nur Zugriff auf die IAM-Identity-Center-Anwendungen von Amazon Redshift hat, denen er zugewiesen ist. Der folgende AWS CLI Befehl listet beispielsweise Anweisungen für einen bestimmten Cluster auf.
```
aws redshift-data list-statements
--cluster-identifier mycluster
```
Sie können auch die Data-API-Operationen aufrufen, die unter Verwendung der Weitergabe von vertrauenswürdigen Identitäten auf Datenbankobjekte in einem Cluster oder einer Arbeitsgruppe zugreifen. Dies umfasst die Operationen `list-databases`, `list-schemas`, `list-tables` und `describe-table`.
API-Aufrufe des IAM-Identity-Center-Benutzers können in AWS CloudTrail nachverfolgt werden. `onBehalfOf`In einem Abschnitt des CloudTrail Ereignisses werden die IAM Identity Center-Benutzer-ID und der Identitätsspeicher-ARN angezeigt. Das folgende Beispiel zeigt einen Ausschnitt eines CloudTrail Ereignisses, das den `onBehalfOf` Abschnitt mit der IAM Identity Center-Benutzer-ID von `a1b2c3d4-5678-90ab-cdef-EXAMPLE11111` und dem Identitätsspeicher-ARN von zeigt. `arn:aws:identitystore::123456789012:identitystore/d-9067bc44d2`
```
{
"eventVersion":"1.10",
"userIdentity":{
"type":"AssumedRole",
...
},
"onBehalfOf":{
"userId":"a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"identityStoreArn":"arn:aws:identitystore::123456789012:identitystore/d-9067bc44d2"
}
},
"eventTime":"2025-01-13T04:46:27Z",
"eventSource":"redshift-data.amazonaws.com",
"eventName":"ExecuteStatement",
"awsRegion":"us-east-1"
}
```
Sie können den folgenden SQL-Befehl ausführen, um die vom IAM-Identity-Center-Benutzer eingereichte Abfrage zu überprüfen. In diesem Beispiel lautet die in Identity Center registrierte E-Mail-Adresse `username@example.com`.
```
SELECT
h.query_id,
h.database_name,
h.status,
h.query_text,
u.usename,
h.start_time,
h.end_time
FROM
sys_query_history h
LEFT JOIN
pg_user u
ON
h.user_id = u.usesysid
where u.usename='awsidc:username@example.com'
ORDER BY
h.start_time DESC;
```
# Aufrufen der Daten-API
Sie können die Daten-API oder die aufrufen AWS CLI , um SQL-Anweisungen auf Ihrem Cluster oder Ihrer serverlosen Arbeitsgruppe auszuführen. Die primären Operationen zum Ausführen von SQL-Anweisungen sind [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html) und [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html) in der *Amazon-Redshift-Daten-API-Referenz*. Die Daten-API unterstützt die Programmiersprachen, die AWS vom SDK unterstützt werden. Weitere Informationen finden Sie unter [Tools für AWS](https://aws.amazon.com/tools/).
Codebeispiele für den Aufruf der Daten-API finden Sie unter [Erste Schritte mit der Redshift Data API](https://github.com/aws-samples/getting-started-with-amazon-redshift-data-api#getting-started-with-redshift-data-api) in *GitHub*. Dieses Repository enthält Beispiele für AWS Lambda den Zugriff auf Amazon Redshift Redshift-Daten aus Amazon EC2 und Amazon AWS Glue Data Catalog SageMaker Runtime. Beispiele für Programmiersprachen sind Python, Go, Java und Javascript.
Sie können die Daten-API über die aufrufe AWS CLI.
In den folgenden Beispielen wird die AWS CLI zum Aufrufen der Daten-API verwendet. Um die Beispiele auszuführen, bearbeiten Sie die Parameterwerte entsprechend Ihrer Umgebung. In vielen Beispielen wird eine `cluster-identifier` gegeben, die gegen einen Cluster ausgeführt wird. Wenn Sie mit einer Serverless-Arbeitsgruppe arbeiten, geben Sie stattdessen einen `workgroup-name` an. Diese Beispiele veranschaulichen einige der Data-API-Vorgänge. Weitere Informationen finden Sie in der *AWS CLI -Befehlsreferenz*.
Die Befehle in den folgenden Beispielen wurden zur besseren Lesbarkeit aufgeteilt und formatiert. Nicht alle Parameter und Antworten werden in allen Beispielen gezeigt. Die API-Definition der vollständigen Anforderungssyntax, der Anforderungsparameter, der Antwortsyntax und der Antwortelemente finden Sie in der [Amazon Redshift Data API Reference](https://docs.aws.amazon.com/redshift-data/latest/APIReference/).
# Übergeben von SQL-Anweisungen an ein Amazon Redshift Data Warehouse
Die Beispiele auf dieser Seite zeigen verschiedene Möglichkeiten, eine SQL-Anweisung an Ihr Data Warehouse zu übergeben
## Ausführen einer SQL-Anweisung
Verwenden Sie den `aws redshift-data execute-statement` AWS CLI Befehl, um eine SQL-Anweisung auszuführen.
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zum Abrufen der Ergebnisse zurück. In diesem Beispiel wird die AWS Secrets Manager -Authentifizierungsmethode verwendet.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zum Abrufen der Ergebnisse zurück. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sql "select * from stl_query limit 1"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für eine serverlose Arbeitsgruppe aus und gibt einen Bezeichner zum Abrufen der Ergebnisse zurück. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data execute-statement
--database dev
--workgroup-name myworkgroup
--sql "select 1;"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"CreatedAt": "2022-02-11T06:25:28.748000+00:00",
"Database": "dev",
"DbUser": "IAMR:RoleName",
"Id": "89dd91f5-2d43-43d3-8461-f33aa093c41e",
"WorkgroupName": "myworkgroup"
}
```
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zum Abrufen der Ergebnisse zurück. In diesem Beispiel werden die Authentifizierungsmethode von AWS Secrets Manager und ein Idempotenz-Token verwendet.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
--client-token b855dced-259b-444c-bc7b-d3e8e33f94g1
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
## Ausführen einer SQL-Anweisung mit Parametern
Verwenden Sie den `aws redshift-data execute-statement` AWS CLI Befehl, um eine SQL-Anweisung auszuführen.
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zum Abrufen der Ergebnisse zurück. In diesem Beispiel wird die AWS Secrets Manager -Authentifizierungsmethode verwendet. Der SQL-Text weist den benannten Parameter `distance` auf. In diesem Fall lautet die im Prädikat verwendete Entfernung `5`. In einer SELECT-Anweisung können benannte Parameter für Spaltennamen nur im Prädikat verwendet werden. Die Werte für benannte Parameter für die SQL-Anweisung werden in der Option `parameters` angegeben.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "SELECT ratecode FROM demo_table WHERE trip_distance > :distance"
--parameters "[{\"name\": \"distance\", \"value\": \"5\"}]"
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
Im folgenden Beispiel wird die `EVENT`-Tabelle aus der Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [EVENT-Tabelle](https://docs.aws.amazon.com/redshift/latest/dg/r_eventtable.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
Wenn Ihre Datenbank noch nicht die `EVENT`-Tabelle enthält, können Sie mit der Data API eine wie folgt erstellen:
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "create table event( eventid integer not null distkey,
venueid smallint not null,
catid smallint not null,
dateid smallint not null sortkey,
eventname varchar(200),
starttime timestamp)"
```
Mit dem folgenden Befehl wird eine Zeile in der `EVENT`-Tabelle eingefügt.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:eventid, :venueid::smallint, :catid, :dateid, :eventname, :starttime)"
--parameters "[{\"name\": \"eventid\", \"value\": \"1\"}, {\"name\": \"venueid\", \"value\": \"1\"},
{\"name\": \"catid\", \"value\": \"1\"},
{\"name\": \"dateid\", \"value\": \"1\"},
{\"name\": \"eventname\", \"value\": \"event 1\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"}]"
```
Mit dem folgenden Befehl wird eine zweite Zeile in der `EVENT`-Tabelle eingefügt. In diesem Beispiel werden die folgenden Aufgaben durchgeführt:
+ Der Parameter namens `id` wird viermal im SQL-Text verwendet.
+ Implizite Typumwandlung wird automatisch angewendet, wenn der Parameter eingefügt wird `starttime`.
+ Für die Spalte `venueid` wird die Typumwandlung in den SMALLINT-Datentyp durchgeführt.
+ Zeichenfolgen, die den Datentyp DATE darstellen, werden implizit in den Datentyp TIMESTAMP konvertiert.
+ Kommentare können in SQL-Text verwendet werden.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:id, :id::smallint, :id, :id, :eventname, :starttime) /*this is comment, and it won't apply parameterization for :id, :eventname or :starttime here*/"
--parameters "[{\"name\": \"eventname\", \"value\": \"event 2\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"},
{\"name\": \"id\", \"value\": \"2\"}]"
```
Hier sehen Sie die beiden eingefügten Zeilen:
```
eventid | venueid | catid | dateid | eventname | starttime
---------+---------+-------+--------+-----------+---------------------
1 | 1 | 1 | 1 | event 1 | 2022-02-22 00:00:00
2 | 2 | 2 | 2 | event 2 | 2022-02-22 00:00:00
```
Der folgende Befehl verwendet einen benannten Parameter in einer WHERE-Klausel, um die Zeile abzurufen, in der `eventid` `1` ist.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "select * from event where eventid=:id"
--parameters "[{\"name\": \"id\", \"value\": \"1\"}]"
```
Führen Sie den folgenden Befehl aus, um die SQL-Ergebnisse der vorherigen SQL-Anweisung abzurufen:
```
aws redshift-data get-statement-result --id 7529ad05-b905-4d71-9ec6-8b333836eb5a
```
Bietet folgende Ergebnisse:
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"stringValue": "event 1"
},
{
"stringValue": "2022-02-22 00:00:00.0"
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "eventid",
"length": 0,
"name": "eventid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "venueid",
"length": 0,
"name": "venueid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "catid",
"length": 0,
"name": "catid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "dateid",
"length": 0,
"name": "dateid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "eventname",
"length": 0,
"name": "eventname",
"nullable": 1,
"precision": 200,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "varchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 1,
"precision": 29,
"scale": 6,
"schemaName": "public",
"tableName": "event",
"typeName": "timestamp"
}
],
"TotalNumRows": 1
}
```
## Ausführen mehrerer SQL-Anweisungen
Um mehrere SQL-Anweisungen mit einem Befehl auszuführen, verwenden Sie den `aws redshift-data batch-execute-statement` AWS CLI Befehl.
Der folgende AWS CLI Befehl führt drei SQL-Anweisungen für einen Cluster aus und gibt einen Bezeichner zum Abrufen der Ergebnisse zurück. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "set timezone to BST" "select * from mytable" "select * from another_table"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
# Auflisten von Metadaten über SQL-Anweisungen
Verwenden Sie den `aws redshift-data list-statements` AWS CLI Befehl, um Metadaten zu SQL-Anweisungen aufzulisten. Die Autorisierung zum Ausführen dieses Befehls basiert auf den IAM-Berechtigungen des Aufrufers.
Der folgende AWS CLI Befehl listet die ausgeführten SQL-Anweisungen auf.
```
aws redshift-data list-statements
--status ALL
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Statements": [
{
"CreatedAt": 1598306924.632,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
},
{
"CreatedAt": 1598311717.437,
"Id": "e0ebd578-58b3-46cc-8e52-8163fd7e01aa",
"QueryString": "select * from stl_query limit 1",
"Status": "FAILED",
"UpdatedAt": 1598311719.008
},
{
"CreatedAt": 1598313683.65,
"Id": "c361d4f7-8c53-4343-8c45-6b2b1166330c",
"QueryString": "select * from stl_query limit 1",
"Status": "ABORTED",
"UpdatedAt": 1598313685.495
},
{
"CreatedAt": 1598306653.333,
"Id": "a512b7bd-98c7-45d5-985b-a715f3cfde7f",
"QueryString": "select 1",
"Status": "FINISHED",
"UpdatedAt": 1598306653.992
}
]
}
```
# Beschreiben von Metadaten über eine SQL-Anweisung
Verwenden Sie den Befehl, um Beschreibungen der Metadaten für eine SQL-Anweisung `aws redshift-data describe-statement` AWS CLI abzurufen. Die Autorisierung zum Ausführen dieses Befehls basiert auf den IAM-Berechtigungen des Aufrufers.
Der folgende AWS CLI Befehl beschreibt eine SQL-Anweisung.
```
aws redshift-data describe-statement
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Duration": 1095981511,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"RedshiftPid": 20859,
"RedshiftQueryId": 48879,
"ResultRows": 1,
"ResultSize": 4489,
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
}
```
Es folgt ein Beispiel für eine `describe-statement`-Antwort nach dem Ausführen eines `batch-execute-statement`-Befehls mit mehreren SQL-Anweisungen.
```
{
"ClusterIdentifier": "mayo",
"CreatedAt": 1623979777.126,
"Duration": 6591877,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652",
"RedshiftPid": 31459,
"RedshiftQueryId": 0,
"ResultRows": 2,
"ResultSize": 22,
"Status": "FINISHED",
"SubStatements": [
{
"CreatedAt": 1623979777.274,
"Duration": 3396637,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:1",
"QueryString": "select 1;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979777.903
},
{
"CreatedAt": 1623979777.274,
"Duration": 3195240,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2",
"QueryString": "select 2;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979778.076
}
],
"UpdatedAt": 1623979778.183
}
```
# Abrufen der Ergebnisse einer SQL-Anweisung
Verwenden Sie den `redshift-data get-statement-result-v2` AWS CLI Befehl `redshift-data get-statement-result` or, um das Ergebnis einer ausgeführten SQL-Anweisung abzurufen. Die Ergebnisse von `get-statement-result` liegen im JSON-Format vor. Die Ergebnisse von `get-statement-result-v2` liegen im CSV-Format vor. Sie können eine `Id` angeben, die Sie als Antwort auf `execute-statement` oder `batch-execute-statement` erhalten. Der `Id`-Wert für eine SQL-Anweisung, die von `batch-execute-statement` ausgeführt wurde, kann im Ergebnis von `describe-statement` abgerufen werden und erhält einen Doppelpunkt und eine Sequenznummer wie `b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2` als Suffix. Wenn Sie mehrere SQL-Anweisungen mit `batch-execute-statement` ausführen, hat jede SQL-Anweisung einen `Id`-Wert wie in `describe-statement` gezeigt. Die Autorisierung zum Ausführen dieses Befehls basiert auf den IAM-Berechtigungen des Aufrufers.
Die folgende Anweisung gibt das Ergebnis einer SQL-Anweisung zurück, die von `execute-statement` ausgeführt wurde und bei der `ResultFormat` standardmäßig auf `JSON` gesetzt wurde. Rufen Sie die Operation `get-statement-result` auf, um die Ergebnisse abzurufen.
```
aws redshift-data get-statement-result
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
Die folgende Anweisung gibt das Ergebnis einer zweiten SQL-Anweisung zurück, die von ausgeführt wurde `batch-execute-statement`.
```
aws redshift-data get-statement-result
--id b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2
```
Im Folgenden sehen Sie ein Beispiel für die Antwort auf einen Aufruf an `get-statement-result`. Das SQL-Ergebnis wird hier im JSON-Format im `Records`-Schlüssel der Antwort zurückgegeben.
```
{
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "userid",
"length": 0,
"name": "userid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "query",
"length": 0,
"name": "query",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "label",
"length": 0,
"name": "label",
"nullable": 0,
"precision": 320,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "xid",
"length": 0,
"name": "xid",
"nullable": 0,
"precision": 19,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int8"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "pid",
"length": 0,
"name": "pid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "database",
"length": 0,
"name": "database",
"nullable": 0,
"precision": 32,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "querytxt",
"length": 0,
"name": "querytxt",
"nullable": 0,
"precision": 4000,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "endtime",
"length": 0,
"name": "endtime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"type": 93,
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "aborted",
"length": 0,
"name": "aborted",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "insert_pristine",
"length": 0,
"name": "insert_pristine",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "concurrency_scaling_status",
"length": 0,
"name": "concurrency_scaling_status",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
}
],
"Records": [
[
{
"longValue": 1
},
{
"longValue": 3
},
{
"stringValue": "health"
},
{
"longValue": 1023
},
{
"longValue": 15279
},
{
"stringValue": "dev"
},
{
"stringValue": "select system_status from stv_gui_status;"
},
{
"stringValue": "2020-08-21 17:33:51.88712"
},
{
"stringValue": "2020-08-21 17:33:52.974306"
},
{
"longValue": 0
},
{
"longValue": 0
},
{
"longValue": 6
}
]
],
"TotalNumRows": 1
}
```
Das folgende Beispiel zeigt eine SQL-Anweisung, die von `execute-statement` ausgeführt wird, um Ergebnisse im JSON-Format zurückzugeben. Die Tabelle `testingtable` enthält drei Ganzzahlspalten (col1, col2, col3) und es gibt drei Zeilen mit Werten (1, 2, 3), (4, 5, 6) und (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format JSON
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Im Folgenden sehen Sie ein Beispiel für die Antwort auf einen Aufruf an `get-statement-result`. Das SQL-Ergebnis wird hier im JSON-Format im `Records`-Schlüssel der Antwort zurückgegeben.
```
aws redshift-data get-statement-result
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 2
},
{
"longValue": 3
}
],
[
{
"longValue": 4
},
{
"longValue": 5
},
{
"longValue": 6
}
],
[
{
"longValue": 7
},
{
"longValue": 8
},
{
"longValue": 9
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3
}
```
Das folgende Beispiel zeigt eine SQL-Anweisung, die von `execute-statement` ausgeführt wird, um Ergebnisse im CSV-Format zurückzugeben. Die Tabelle `testingtable` enthält drei Ganzzahlspalten (col1, col2, col3) und es gibt drei Zeilen mit Werten (1, 2, 3), (4, 5, 6) und (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format CSV
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Im Folgenden sehen Sie ein Beispiel für die Antwort auf einen Aufruf an `get-statement-result-v2`. Das SQL-Ergebnis wird hier im CSV-Format im `Records`-Schlüssel der Antwort zurückgegeben. Zeilen werden durch Wagenrücklauf und Zeilenvorschub (\$1r\$1n) getrennt. Die erste Zeile, die in `Records` zurückgegeben wird, sind die Spaltenüberschriften. Die Ergebnisse im CSV-Format werden in 1-MB-Blöcken zurückgegeben, wobei in jedem Block eine beliebige Anzahl von Zeilen bis zu 1 MB gespeichert werden kann.
```
aws redshift-data get-statement-result-v2
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
{
"CSVRecords": "col1,col2,col3\r\n1,2,3\r\n4,5,6\r\n7,8,9\r\n"
}
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3,
"ResultFormat": "csv"
}
```
# Beschreiben einer Tabelle
Verwenden Sie den `aws redshift-data describe-table` AWS CLI Befehl, um Metadaten abzurufen, die eine Tabelle beschreiben.
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt Metadaten zurück, die eine Tabelle beschreiben. In diesem Beispiel wird die AWS Secrets Manager Authentifizierungsmethode verwendet.
```
aws redshift-data describe-table
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, der eine Tabelle beschreibt. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data describe-table
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_supported",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_verified_by",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "comments",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
# Auflisten von Datenbanken in einem Cluster
Verwenden Sie den `aws redshift-data list-databases` AWS CLI Befehl, um die Datenbanken in einem Cluster aufzulisten.
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Datenbanken aufzulisten. In diesem Beispiel wird die AWS Secrets Manager Authentifizierungsmethode verwendet.
```
aws redshift-data list-databases
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Databases": [
"dev"
]
}
```
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Datenbanken aufzulisten. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data list-databases
--db-user myuser
--cluster-identifier mycluster-test
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Databases": [
"dev"
]
}
```
# Auflisten von Schemata in einer Datenbank
Verwenden Sie den `aws redshift-data list-schemas` AWS CLI Befehl, um die Schemas in einer Datenbank aufzulisten.
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Schemas in einer Datenbank aufzulisten. In diesem Beispiel wird die AWS Secrets Manager Authentifizierungsmethode verwendet.
```
aws redshift-data list-schemas
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Schemas in einer Datenbank aufzulisten. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data list-schemas
--db-user mysuser
--cluster-identifier mycluster-test
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
# Auflisten von Tabellen in einer Datenbank
Verwenden Sie den `aws redshift-data list-tables` AWS CLI Befehl, um die Tabellen in einer Datenbank aufzulisten.
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Tabellen in einer Datenbank aufzulisten. In diesem Beispiel wird die AWS Secrets Manager Authentifizierungsmethode verwendet.
```
aws redshift-data list-tables
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
}
```
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Tabellen in einer Datenbank aufzulisten. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data list-tables
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
]
}
```
# Beheben von Problemen mit der Amazon Redshift Data API
Verwenden Sie die folgenden Abschnitte mit dem Titel "Allgemeine Fehlermeldungen", um Probleme zu beheben, die Sie mit der Data-API haben.
**Topics**
+ [Packet for Query Is Too Large (Paket für Abfrage zu groß)](#data-api-troubleshooting-packet-too-large)
+ [Database Response Exceeded Size Limit Datenbankantwort überschreitet Größenlimit)](#data-api-troubleshooting-response-size-too-large)
## Packet for Query Is Too Large (Paket für Abfrage zu groß)
Wenn ein Fehler angezeigt wird, der angibt, dass das Paket für eine Abfrage zu groß ist, ist meist die Ergebnismenge, die für eine Zeile zurückgegeben wurde, zu groß. Die Größenbegrenzung der Data-API beträgt 64 KB pro Zeile in der von der Datenbank zurückgegebenen Ergebnismenge.
Um dieses Problem zu beheben, stellen Sie sicher, dass jede Zeile in einem Ergebnissatz höchstens 64 KB groß ist.
## Database Response Exceeded Size Limit Datenbankantwort überschreitet Größenlimit)
Wenn Sie einen Fehler sehen, der darauf hinweist, dass die Datenbankantwort die Größenbeschränkung überschritten hat, war meist die von der Datenbank zurückgegebene Ergebnismenge zu groß. Das Daten-API-Limit in der von der Datenbank zurückgegebenen Ergebnismenge beträgt 500 MB.
Um dieses Problem zu lösen, stellen Sie sicher, dass Aufrufe der Daten-API 500 MB Daten oder weniger zurückgeben. Wenn Sie mehr als 500 MB zurückgeben müssen, können Sie mehrere Anweisungsaufrufe mit der `LIMIT` Klausel in Ihrer Abfrage ausführen.
# Planung von Amazon Redshift Data API-Vorgängen mit Amazon EventBridge
Sie können Regeln für ausgewählte Ereignisse erstellen und an Ziele weiterleiten, um Aktionen durchzuführen. Sie können auch Regeln verwenden, um Aktionen nach einem vorher festgelegten Zeitplan durchzuführen. Weitere Informationen finden Sie im [ EventBridge Amazon-Benutzerhandbuch](https://docs.aws.amazon.com/eventbridge/latest/userguide/).
Um Daten-API-Operationen mit planen zu können EventBridge, muss die zugehörige IAM-Rolle dem Principal for CloudWatch Events (events.amazonaws.com) vertrauen. Dieser Rolle sollte das Äquivalent der verwalteten Richtlinie `AmazonEventBridgeFullAccess` zugewiesen sein. Sie sollte auch über `AmazonRedshiftDataFullAccess`-Richtlinienberechtigungen verfügen, die von der Data API verwaltet werden. Sie können eine IAM-Rolle mit diesen Berechtigungen in der IAM-Konsole erstellen. Wählen Sie bei der Erstellung einer Rolle in der IAM-Konsole die vertrauenswürdige Service-Entität für Ereignisse aus. AWS CloudWatch Geben Sie die IAM-Rolle im `RoleArn` JSON-Wert im Ziel an EventBridge . Weitere Informationen zum Erstellen einer IAM-Rolle finden Sie unter [Creating a Role for an AWS Service (Console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console) im *IAM-Benutzerhandbuch*.
Die `name` Regel, die Sie in Amazon erstellen, EventBridge muss mit der `StatementName` in der übereinstimmen`RedshiftDataParameters`.
Die folgenden Beispiele zeigen Varianten der EventBridge Regelerstellung mit einer oder mehreren SQL-Anweisungen und mit einem Amazon Redshift-Cluster oder einer Amazon Redshift Serverless-Arbeitsgruppe als Data Warehouse.
## Aufrufen mit einer einzigen SQL-Anweisung und einem Cluster
Das folgende Beispiel verwendet die AWS CLI , um eine EventBridge Regel zu erstellen, die verwendet wird, um eine SQL-Anweisung für einen Amazon Redshift Redshift-Cluster auszuführen.
```
aws events put-rule
--name test-redshift-cluster-data
--schedule-expression "rate(1 minute)"
```
Dann wird ein EventBridge Ziel erstellt, das nach dem in der Regel angegebenen Zeitplan ausgeführt wird.
```
aws events put-targets
--cli-input-json file://data.json
```
Die data.json-Eingabedatei ist wie folgt. Der JSON-Schlüssel `Sql` gibt an, dass es nur eine einzige SQL-Anweisung gibt. Der JSON-Wert `Arn` enthält eine Clusterkennung. Der JSON-Wert `RoleArn` enthält die IAM-Rolle, die verwendet wird, um SQL wie zuvor beschrieben auszuführen.
```
{
"Rule": "test-redshift-cluster-data",
"EventBusName": "default",
"Targets": [
{
"Id": "2",
"Arn": "arn:aws:redshift:us-east-1:123456789012:cluster:mycluster",
"RoleArn": "arn:aws:iam::123456789012:role/Administrator",
"RedshiftDataParameters": {
"Database": "dev",
"DbUser": "root",
"Sql": "select 1;",
"StatementName": "test-redshift-cluster-data",
"WithEvent": true
}
}
]
}
```
## Aufrufen mit einer einzigen SQL-Anweisung und einer Arbeitsgruppe
Das folgende Beispiel verwendet die AWS CLI , um eine EventBridge Regel zu erstellen, die verwendet wird, um eine SQL-Anweisung für eine Amazon Redshift Serverless-Arbeitsgruppe auszuführen.
```
aws events put-rule
--name test-redshift-serverless-workgroup-data
--schedule-expression "rate(1 minute)"
```
Dann wird ein EventBridge Ziel erstellt, das nach dem in der Regel angegebenen Zeitplan ausgeführt wird.
```
aws events put-targets
--cli-input-json file://data.json
```
Die data.json-Eingabedatei ist wie folgt. Der JSON-Schlüssel `Sql` gibt an, dass es nur eine einzige SQL-Anweisung gibt. Der JSON-Wert `Arn` enthält einen Arbeitsgruppennamen. Der JSON-Wert `RoleArn` enthält die IAM-Rolle, die verwendet wird, um SQL wie zuvor beschrieben auszuführen.
```
{
"Rule": "test-redshift-serverless-workgroup-data",
"EventBusName": "default",
"Targets": [
{
"Id": "2",
"Arn": "arn:aws:redshift-serverless:us-east-1:123456789012:workgroup/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"RoleArn": "arn:aws:iam::123456789012:role/Administrator",
"RedshiftDataParameters": {
"Database": "dev",
"Sql": "select 1;",
"StatementName": "test-redshift-serverless-workgroup-data",
"WithEvent": true
}
}
]
}
```
## Aufrufen mit mehreren SQL-Anweisungen und einem Cluster
Das folgende Beispiel verwendet die AWS CLI , um eine EventBridge Regel zu erstellen, die verwendet wird, um mehrere SQL-Anweisungen für einen Amazon Redshift Redshift-Cluster auszuführen.
```
aws events put-rule
--name test-redshift-cluster-data
--schedule-expression "rate(1 minute)"
```
Dann wird ein EventBridge Ziel erstellt, das nach dem in der Regel angegebenen Zeitplan ausgeführt wird.
```
aws events put-targets
--cli-input-json file://data.json
```
Die data.json-Eingabedatei ist wie folgt. Der JSON-Schlüssel `Sqls` gibt an, dass es mehrere SQL-Anweisungen gibt. Der JSON-Wert `Arn` enthält eine Clusterkennung. Der JSON-Wert `RoleArn` enthält die IAM-Rolle, die verwendet wird, um SQL wie zuvor beschrieben auszuführen.
```
{
"Rule": "test-redshift-cluster-data",
"EventBusName": "default",
"Targets": [
{
"Id": "2",
"Arn": "arn:aws:redshift:us-east-1:123456789012:cluster:mycluster",
"RoleArn": "arn:aws:iam::123456789012:role/Administrator",
"RedshiftDataParameters": {
"Database": "dev",
"Sqls": ["select 1;", "select 2;", "select 3;"],
"StatementName": "test-redshift-cluster-data",
"WithEvent": true
}
}
]
}
```
## Aufrufen mit mehreren SQL-Anweisungen und einer Arbeitsgruppe
Das folgende Beispiel verwendet die AWS CLI , um eine EventBridge Regel zu erstellen, die verwendet wird, um mehrere SQL-Anweisungen für eine Amazon Redshift Serverless-Arbeitsgruppe auszuführen.
```
aws events put-rule
--name test-redshift-serverless-workgroup-data
--schedule-expression "rate(1 minute)"
```
Dann wird ein EventBridge Ziel erstellt, das nach dem in der Regel angegebenen Zeitplan ausgeführt wird.
```
aws events put-targets
--cli-input-json file://data.json
```
Die data.json-Eingabedatei ist wie folgt. Der JSON-Schlüssel `Sqls` gibt an, dass es mehrere SQL-Anweisungen gibt. Der JSON-Wert `Arn` enthält einen Arbeitsgruppennamen. Der JSON-Wert `RoleArn` enthält die IAM-Rolle, die verwendet wird, um SQL wie zuvor beschrieben auszuführen.
```
{
"Rule": "test-redshift-serverless-workgroup-data",
"EventBusName": "default",
"Targets": [
{
"Id": "2",
"Arn": "arn:aws:redshift-serverless:us-east-1:123456789012:workgroup/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"RoleArn": "arn:aws:iam::123456789012:role/Administrator",
"RedshiftDataParameters": {
"Database": "dev",
"Sqls": ["select 1;", "select 2;", "select 3;"],
"StatementName": "test-redshift-serverless-workgroup-data",
"WithEvent": true
}
}
]
}
```
# Überwachen der Data API
Die Überwachung ist ein wichtiger Bestandteil der Aufrechterhaltung der Zuverlässigkeit, Verfügbarkeit und Leistung der Daten-API und Ihrer anderen AWS Lösungen. AWS bietet die folgenden Überwachungstools, um die Daten-API zu überwachen, zu melden, wenn etwas nicht stimmt, und gegebenenfalls automatische Maßnahmen zu ergreifen:
+ Amazon EventBridge kann verwendet werden, um Ihre AWS Services zu automatisieren und automatisch auf Systemereignisse wie Probleme mit der Anwendungsverfügbarkeit oder Ressourcenänderungen zu reagieren. Ereignisse im Rahmen von AWS Services werden nahezu EventBridge in Echtzeit zugestellt. Sie können einfache Regeln schreiben, um anzugeben, welche Ereignisse für Sie interessant sind und welche automatisierten Aktionen ausgeführt werden sollen, wenn ein Ereignis mit einer Regel übereinstimmt. Weitere Informationen finden Sie im [ EventBridge Amazon-Benutzerhandbuch](https://docs.aws.amazon.com/eventbridge/latest/userguide/).
+ AWS CloudTrail erfasst API-Aufrufe und zugehörige Ereignisse, die von oder im Namen Ihres AWS Kontos getätigt wurden, und übermittelt die Protokolldateien an einen von Ihnen angegebenen Amazon S3 S3-Bucket. Sie können feststellen, welche Benutzer und Konten angerufen wurden AWS, von welcher Quell-IP-Adresse aus die Anrufe getätigt wurden und wann die Aufrufe erfolgten. Weitere Informationen zur Integration von Amazon Redshift finden Sie unter [Logging with CloudTrail](https://docs.aws.amazon.com/redshift/latest/mgmt/logging-with-cloudtrail.html). AWS CloudTrail Weitere Informationen zu CloudTrail finden Sie im [AWS CloudTrail Benutzerhandbuch](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
**Topics**
+ [Überwachung von Ereignissen für die Amazon Redshift Data API in Amazon EventBridge](data-api-monitoring-events.md)
# Überwachung von Ereignissen für die Amazon Redshift Data API in Amazon EventBridge
Sie können Daten-API-Ereignisse überwachen EventBridge, wodurch ein Stream von Echtzeitdaten aus Ihren eigenen Anwendungen, software-as-a-service (SaaS-) Anwendungen und AWS Diensten bereitgestellt wird. EventBridge leitet diese Daten an Ziele wie AWS Lambda Amazon SNS weiter. Bei diesen Ereignissen handelt es sich um dieselben Ereignisse, die unter CloudWatch Ereignisse angezeigt werden. Dadurch wird ein Stream von Systemereignissen nahezu in Echtzeit bereitgestellt, die Änderungen an Ressourcen beschreiben. AWS Ereignisse werden an das Konto gesendet, das die Amazon-Redshift-Datenbank enthält. Wenn Sie beispielsweise eine Rolle in einem anderen Konto übernehmen, werden Ereignisse an dieses Konto gesendet. Weitere Informationen finden Sie unter [ EventBridge Amazon-Veranstaltungen](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) im * EventBridge Amazon-Benutzerhandbuch.* .
Data-API-Ereignisse werden gesendet, wenn der API-Vorgang `ExecuteStatement` oder `BatchExecuteStatement` die Option `WithEvent` auf `true` festlegt. Das `state`-Feld des Ereignisses enthält einen der folgenden Werte:
+ ABBORTED – Die Abfrage wurde vom Benutzer gestoppt.
+ FAILED – Die Ausführung der Abfrage ist fehlgeschlagen.
+ FINISHED – Die Ausführung der Abfrage ist abgeschlossen.
Ereignisse werden garantiert geliefert. Weitere Informationen finden Sie unter [Events from AWS services](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-service-event.html) im * EventBridge Amazon-Benutzerhandbuch*.
## Beispiel für abgeschlossenes Data-API-Ereignis
Das folgende Beispiel zeigt ein Ereignis für die Data API, wenn der API-Vorgang `ExecuteStatement` abgeschlossen ist. Im folgenden Beispiel hat eine Anweisung namens `test.testtable` die Ausführung abgeschlossen.
```
{
"version": "0",
"id": "18e7079c-dd4b-dd64-caf9-e2a31640dab0",
"detail-type": "Redshift Data Statement Status Change",
"source": "aws.redshift-data",
"account": "123456789012",
"time": "2020-10-01T21:14:26Z",
"region": "us-east-1",
"resources": [
"arn:aws:redshift:us-east-1:123456789012:cluster:redshift-cluster-1"
],
"detail": {
"principal": "arn:aws:iam::123456789012:user/myuser",
"statementName": "test.testtable",
"statementId": "dd2e1ec9-2ee3-49a0-819f-905fa7d75a4a",
"redshiftQueryId": -1,
"state": "FINISHED",
"rows": 1,
"expireAt": 1601673265
}
}
```
# Verwendung AWS KMS mit der Amazon Redshift Data API
Wenn Sie Ihren Amazon Redshift-Cluster oder Ihre Redshift Serverless-Arbeitsgruppe mit einem vom Kunden verwalteten Schlüssel verschlüsseln, verwendet die Amazon Redshift Data API denselben kundenverwalteten Schlüssel, um Ihre Abfragen und Ergebnisse zu speichern und zu verschlüsseln.
Die Daten-API verschlüsselt Ihre Daten standardmäßig, um vertrauliche Informationen wie Abfragetext und Abfrageergebnisse zu schützen. AWS Für diesen Schutz werden AWS KMS Verschlüsselungsschlüssel verwendet, die Eigentum von sind.
Die Standardverschlüsselung für ruhende Daten reduziert den betrieblichen Aufwand und die Komplexität beim Schutz sensibler Daten. Dieser Ansatz hilft Ihnen dabei, sichere Anwendungen zu entwickeln, die strenge Verschlüsselungsvorschriften und regulatorische Anforderungen erfüllen.
## Verwendung von Zuschüssen in AWS KMS
Für die Daten-API ist eine Genehmigung erforderlich, um Ihren vom Kunden verwalteten Schlüssel verwenden zu können.
Wenn Sie einen Cluster anrufen `ExecuteStatement` oder `BatchExecuteStatement` gegen einen Cluster anrufen, der mit einem vom Kunden verwalteten Schlüssel verschlüsselt ist, erstellt Amazon Redshift in Ihrem Namen einen Zuschuss, indem es eine [https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)Anfrage an AWS KMS sendet. AWS KMS verwendet Zuschüsse, um der Daten-API Zugriff auf einen KMS-Schlüssel in Ihrem Konto zu gewähren.
Für die Daten-API ist die Genehmigung erforderlich, um Ihren vom Kunden verwalteten Schlüssel für die folgenden Vorgänge zu verwenden:
+ Senden Sie [https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html)Anfragen AWS KMS zur Verschlüsselung von Abfrage-Metadaten mit Ihrem vom Kunden verwalteten Schlüssel an.
+ Senden Sie [https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)Anfragen AWS KMS zur Generierung von Datenschlüsseln, die mit Ihrem vom Kunden verwalteten Schlüssel verschlüsselt sind.
+ Senden Sie [https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)Anfragen AWS KMS zur Entschlüsselung der verschlüsselten Datenschlüssel, damit diese Ihre Daten verschlüsseln können.
Sie können den Zugriff auf die Gewährung jederzeit widerrufen oder Amazon Redshift Redshift-Zugriff auf Ihren vom Kunden verwalteten Schlüssel entfernen. Wenn Sie dies tun, kann die Daten-API nicht mehr auf Daten zugreifen, die mit Ihrem vom Kunden verwalteten Schlüssel verschlüsselt wurden, was sich auf Vorgänge auswirkt, die von diesen Daten abhängen. Wenn Sie beispielsweise versuchen, Abfrageergebnisse abzurufen oder den Abfragestatus zu verfolgen, nachdem Sie den Zuschuss widerrufen haben, gibt die Daten-API eine `AccessDeniedException` zurück.
## Wichtige Richtlinien für Ihren vom Kunden verwalteten Schlüssel
Schlüsselrichtlinien steuern den Zugriff auf den vom Kunden verwalteten Schlüssel. Jeder vom Kunden verwaltete Schlüssel muss über genau eine Schlüsselrichtlinie verfügen, die aussagt, wer den Schlüssel wie verwenden kann. Wenn Sie Ihren kundenseitig verwalteten Schlüssel erstellen, können Sie eine Schlüsselrichtlinie angeben. Weitere Informationen finden Sie unter [Kundenverwaltete Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-mgn-key) im *AWS Key Management Service Entwicklerhandbuch*.
Um Ihre vom Kunden verwalteten Schlüssel mit der Daten-API zu verwenden, müssen Sie zunächst den Zugriff auf Amazon Redshift zulassen. Die folgenden API-Operationen müssen in der Schlüsselrichtlinie zulässig sein:
+ `kms:CreateGrant`: Fügt einem kundenverwalteten Schlüssel eine Erteilung hinzu. Gewährt Kontrollzugriff auf einen bestimmten AWS KMS Schlüssel, der Zugriff auf Grant-Operationen ermöglicht, die Amazon Redshift benötigt. Weitere Informationen finden Sie unter [Verwenden von Zuschüssen in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations).
Im Folgenden finden Sie ein Beispiel für eine wichtige Richtlinie:
```
"Statement":[
{
"Sid":"Allow access to principals authorized to use Amazon Redshift",
"Effect":"Allow",
"Principal":{
"AWS":"*"
},
"Action":[
"kms:DescribeKey",
"kms:CreateGrant"
],
"Resource":"*",
"Condition":{
"StringEquals":{
"kms:ViaService":"redshift.amazonaws.com",
"kms:CallerAccount":"111122223333"
}
}
},
{
"Sid":"AllowKeyAdministratorsAccess",
"Effect":"Allow",
"Principal":{
"AWS":"arn:aws:iam::111122223333:role/ExampleAdminRole"
},
"Action":"kms:*",
"Resource":"*"
},
{
"Sid":"AllowKeyUseForExampleRole",
"Effect":"Allow",
"Principal":{
"AWS":"arn:aws:iam::111122223333:role/ExampleUserRole"
},
"Action":[
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource":"*"
}
]
```
## Kontext der Daten-API-Verschlüsselung
Ein Verschlüsselungskontext ist ein optionaler Satz von Schlüssel-Wert-Paaren, der zusätzliche kontextbezogene Informationen zu den Daten enthält. AWS KMS verwendet den Verschlüsselungskontext als zusätzliche authentifizierte Daten, um die authentifizierte Verschlüsselung zu unterstützen. Wenn Sie einen Verschlüsselungskontext in eine Anforderung zum Verschlüsseln von Daten einbeziehen, wird der Verschlüsselungskontext AWS KMS an die verschlüsselten Daten gebunden. Um die Daten zu entschlüsseln, müssen Sie denselben Verschlüsselungskontext in die Anforderung aufnehmen.
Die Daten-API verwendet bei allen AWS KMS kryptografischen Vorgängen für bereitgestellte Cluster dieselben drei Schlüssel-Wert-Paare für den Verschlüsselungskontext:
+ `aws:redshift:arn`— Der Amazon-Ressourcenname (ARN) des Clusters
+ `aws:redshift:createtime`— Der Zeitstempel, als Sie die Cluster-Erstellung angefordert haben
+ `serviceName` – `RedshiftDataAPI`
```
"EncryptionContextSubset": {
"aws:redshift:arn": "arn:aws:redshift:us-east-1:123456789012:cluster:redshift-cluster",
"aws:redshift:createtime": "20250815T0000Z",
"serviceName": "RedshiftDataAPI",
}
```
Die Daten-API verwendet bei allen AWS KMS kryptografischen Vorgängen für serverlose Arbeitsgruppen zwei Schlüssel-Wert-Paare aus dem Verschlüsselungskontext:
+ `aws:redshift-serverless:arn`— Der Amazon-Ressourcenname (ARN) des Namespaces
+ `serviceName`— API RedshiftData
```
"EncryptionContextSubset": {
"aws:redshift-serverless:arn": "arn:aws:redshift-serverless:us-east-1:123456789012:namespace:12345678-1234-1234-1234-123456789012",
"serviceName": "RedshiftDataAPI"
}
```
Weitere Informationen zur Verschlüsselung finden Sie unter [Einführung in die kryptografischen Details von AWS KMS](https://docs.aws.amazon.com/kms/latest/cryptographic-details/intro.html). Weitere Informationen zu Amazon Redshift und dessen AWS KMS Integration finden Sie unter [Verwendung von Amazon Redshift](https://docs.aws.amazon.com/kms/latest/developerguide/services-redshift.html). AWS KMS