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 Daten-API von Amazon RDS
Wenn Sie die RDS-Daten-API (Daten-API) verwenden, können Sie mit einer Webservices-Schnittstelle zu Ihrem Aurora-DB-Cluster arbeiten. Die Daten-API erfordert keine beständige Verbindung zum DB-Cluster. 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.
Benutzer müssen bei Aufrufen an die Daten-API keine Anmeldeinformationen weitergeben, da die Daten-API Datenbankanmeldeinformationen verwendet, die in gespeichert sind AWS Secrets Manager. Um Anmeldeinformationen in Secrets Manager speichern zu können, müssen Benutzer die entsprechenden Berechtigungen zur Verwendung von Secrets Manager und der Daten-API erhalten. Weitere Informationen zum Autorisieren von Benutzern finden Sie unter [Autorisieren des Zugriffs auf die Amazon-RDS-Daten-API](data-api.access.md).
Sie können die Daten-API auch verwenden, um Amazon Aurora in andere AWS Anwendungen wie AWS Lambda AWS AppSync, und zu integrieren AWS Cloud9. Die Daten-API bietet auch eine sicherere Möglichkeit für die Verwendung von AWS Lambda. Sie können damit auf Ihr DB-Cluster zugreifen, ohne eine Lambda-Funktion für den Zugriff auf Ressourcen in einer Virtual Private Cloud (VPC) konfigurieren zu müssen. Weitere Informationen finden Sie unter [AWS Lambda](https://aws.amazon.com/lambda/), [AWS AppSync](https://aws.amazon.com/appsync/) und [AWS Cloud9](https://aws.amazon.com/cloud9/).
Sie können die Daten-API aktivieren, wenn Sie den Aurora-DB-Cluster erstellen. Sie können die Konfiguration später auch ändern. Weitere Informationen finden Sie unter [Aktivieren der Amazon-RDS-Daten-API](data-api.enabling.md).
Nach Aktivierung der Daten-API können Sie auch den Abfrage-Editor verwenden, um Ad-hoc-Abfragen auszuführen, ohne ein Abfrage-Werkzeug für den Zugriff auf Aurora in einer VPC zu konfigurieren. Weitere Informationen finden Sie unter [Arbeiten mit dem Aurora-Abfrage-Editor](query-editor.md).
**Topics**
+ [
# Verfügbarkeit von Regionen und Versionen für die Amazon-RDS-Daten-API
](data-api.regions.md)
+ [
# Verwendung IPv6 mit der Amazon RDS-Daten-API
](data-api.ipv6.md)
+ [
# Einschränkungen der Amazon-RDS-Daten-API
](data-api.limitations.md)
+ [
# Vergleich zum Verhalten der Daten-API von Amazon RDS – bei Aurora Serverless v2 und bereitgestellten Clustern und bei Aurora Serverless v1-Clustern
](data-api.differences.md)
+ [
# Autorisieren des Zugriffs auf die Amazon-RDS-Daten-API
](data-api.access.md)
+ [
# Aktivieren der Amazon-RDS-Daten-API
](data-api.enabling.md)
+ [
# Erstellen eines Amazon-VPC-Endpunkts für die Amazon-RDS-Daten-API (AWS PrivateLink)
](data-api.vpc-endpoint.md)
+ [
# Aufrufen der Daten-API von Amazon RDS
](data-api.calling.md)
+ [
# Verwenden der Java-Client-Bibliothek für die RDS-Daten-API
](data-api.java-client-library.md)
+ [
# Verarbeiten von Abfrageergebnissen der Amazon-RDS-Data-API im JSON-Format
](data-api-json.md)
+ [
# Fehlerbehebung bei Problemen mit der Amazon-RDS-Daten-API
](data-api.troubleshooting.md)
+ [
# Protokollieren von Amazon RDS Data API-Aufrufen mit AWS CloudTrail
](logging-using-cloudtrail-data-api.md)
+ [
# Überwachen von RDS-Daten-API-Abfragen mit Performance Insights
](monitoring-using-performance-insights-data-api.md)
# Verfügbarkeit von Regionen und Versionen für die Amazon-RDS-Daten-API
Informationen zu den Regionen und Engine-Versionen, die für die Daten-API verfügbar sind, finden Sie in folgenden Abschnitten.
| Cluster-Typ | Verfügbarkeit von Regionen und Versionen |
| --- | --- |
| Aurora PostgreSQL, bereitgestellt und Serverless v2 | [Daten-API mit Aurora PostgreSQL Serverless v2 und bereitgestellt](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.md#Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.apg) |
| Aurora MySQL, bereitgestellt und Serverless v2 | [Daten-API mit Aurora MySQL Serverless v2 und bereitgestellt](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.md#Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.ams) |
| Aurora PostgreSQL Serverless v1 | [Daten-API mit Aurora PostgreSQL Serverless v1](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.md#Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.apg-sv1) |
| Aurora MySQL Serverless v1 | [Daten-API mit Aurora MySQL Serverless v1](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.md#Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.amy) |
Wenn Sie kryptografische Module benötigen, die von FIPS 140-2 validiert werden, wenn Sie über eine Befehlszeilenschnittstelle oder eine API auf die Daten-API zugreifen, verwenden Sie einen FIPS-Endpunkt. Weitere Informationen über verfügbare FIPS-Endpunkte finden Sie unter [Federal Information Processing Standard (FIPS) 140-2](https://aws.amazon.com/compliance/fips/).
# Verwendung IPv6 mit der Amazon RDS-Daten-API
Die Amazon RDS Data API unterstützt IPv6 Konnektivität über Dual-Stack-Endpunkte. Auf diese Weise können Sie mithilfe von IPv6 Adressen eine Verbindung zur Daten-API herstellen und gleichzeitig die Abwärtskompatibilität mit beibehalten. IPv4
## IPv6 Endpunkt-Unterstützung
Die Daten-API bietet Dual-Stack-Endpunkte, die IPv4 sowohl IPv6 Verbindungen als auch unterstützen. Diese Endpunkte verwenden die `.aws`-Domain anstelle der herkömmlichen `.amazonaws.com`-Domain.
### Verfügbare Endpunkttypen
Öffentliche Dual-Stack-Endpunkte
Format: `rds-data.region.api.aws`
Beispiel: `rds-data.us-east-1.api.aws`
FIPS-Dual-Stack-Endpunkte
Format: `rds-data-fips.region.api.aws`
Beispiel: `rds-data-fips.us-east-1.api.aws`
PrivateLink IPv6 Endpunkte
Verfügbar über VPC-Endpunkte mit Support IPv6
Ermöglicht private IPv6 Konnektivität innerhalb Ihrer VPC
### Endpunkte, die nur aus IPv4 Legacy-Versionen bestehen
Die vorhandenen `.amazonaws.com` Endpunkte unterstützen IPv4 weiterhin reine Verbindungen:
+ `rds-data.region.amazonaws.com`
+ `rds-data-fips.region.amazonaws.com`
**Anmerkung**
Ältere Endpunkte bleiben unverändert, um die Abwärtskompatibilität mit bestehenden Anwendungen zu gewährleisten.
## Endpunkte verwenden IPv6
Um die Anwendung IPv6 mit der Daten-API zu verwenden, aktualisieren Sie Ihre Anwendung so, dass sie die neuen Dual-Stack-Endpunkte verwendet. Ihre Anwendung wird automatisch verwendet, IPv6 sofern verfügbar, oder es wird darauf zurückgegriffen. IPv4
Allgemeine Hinweise zur Einrichtung IPv6 in Ihrer VPC finden Sie unter [Migration zu IPv6](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-migrate-ipv6.html) im *Amazon VPC-Benutzerhandbuch*.
Sie können IPv6 Endpoints auf zwei Arten konfigurieren:
+ **Umgebungsvariable verwenden**: `AWS_USE_DUALSTACK_ENDPOINT=true` In Ihrer IPv6 Umgebung festgelegt. Das AWS CLI und erstellt AWS SDKs automatisch die entsprechenden `api.aws` Endpunkte, ohne dass Sie den Endpunkt URLs manuell angeben müssen.
+ **Verwenden eines expliziten Endpunkts URLs**: Geben Sie die Dual-Stack-Endpunkt-URL direkt in Ihren AWS CLI Befehlen oder Ihrer SDK-Konfiguration an, wie in den folgenden Beispielen gezeigt.
### AWS CLI Konfiguration
Konfigurieren Sie die AWS CLI für die Verwendung von IPv6 Endpunkten, indem Sie die Endpunkt-URL angeben:
Für Linux, macOS oder Unix:
```
aws rds-data execute-statement \
--endpoint-url https://rds-data.us-east-1.api.aws \
--resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:my-cluster" \
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret" \
--database "mydb" \
--sql "SELECT * FROM users LIMIT 10"
```
Für Windows:
```
aws rds-data execute-statement ^
--endpoint-url https://rds-data.us-east-1.api.aws ^
--resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:my-cluster" ^
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret" ^
--database "mydb" ^
--sql "SELECT * FROM users LIMIT 10"
```
### AWS SDK-Konfiguration
Für AWS SDKs die Verwendung von Dual-Stack-Endpunkten konfigurieren:
------
#### [ Python ]
```
import boto3
# Create RDS Data API client with IPv6 dual-stack endpoint
client = boto3.client(
'rds-data',
endpoint_url='https://rds-data.us-east-1.api.aws'
)
# Execute a SQL statement
response = client.execute_statement(
resourceArn='arn:aws:rds:us-east-1:123456789012:cluster:my-cluster',
secretArn='arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret',
database='mydb',
sql='SELECT * FROM users LIMIT 10'
)
print(response['records'])
```
------
#### [ Java ]
```
import software.amazon.awssdk.services.rdsdata.RdsDataClient;
import software.amazon.awssdk.services.rdsdata.model.ExecuteStatementRequest;
import software.amazon.awssdk.services.rdsdata.model.ExecuteStatementResponse;
import java.net.URI;
// Create RDS Data API client with IPv6 dual-stack endpoint
RdsDataClient client = RdsDataClient.builder()
.endpointOverride(URI.create("https://rds-data.us-east-1.api.aws"))
.build();
// Execute a SQL statement
ExecuteStatementRequest request = ExecuteStatementRequest.builder()
.resourceArn("arn:aws:rds:us-east-1:123456789012:cluster:my-cluster")
.secretArn("arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret")
.database("mydb")
.sql("SELECT * FROM users LIMIT 10")
.build();
ExecuteStatementResponse response = client.executeStatement(request);
System.out.println(response.records());
```
------
#### [ JavaScript ]
```
const { RDSDataClient, ExecuteStatementCommand } = require("@aws-sdk/client-rds-data");
// Create RDS Data API client with IPv6 dual-stack endpoint
const client = new RDSDataClient({
endpoint: "https://rds-data.us-east-1.api.aws"
});
// Execute a SQL statement
const command = new ExecuteStatementCommand({
resourceArn: "arn:aws:rds:us-east-1:123456789012:cluster:my-cluster",
secretArn: "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret",
database: "mydb",
sql: "SELECT * FROM users LIMIT 10"
});
const response = await client.send(command);
console.log(response.records);
```
------
## Verwenden mit AWS PrivateLink IPv6
Sie können VPC-Endpunkte für die Daten-API erstellen, die IPv6 Konnektivität innerhalb Ihrer VPC unterstützen. Ausführliche Anleitungen zum Erstellen von VPC-Endpunkten für die Daten-API finden Sie unter [Erstellen eines Amazon-VPC-Endpunkts für die Amazon-RDS-Daten-API (AWS PrivateLink)](data-api.vpc-endpoint.md).
Stellen Sie beim Erstellen eines VPC-Endpunkts für den IPv6 Support sicher, dass:
+ Ihre VPC und Subnetze sind für die Unterstützung konfiguriert IPv6
+ Sicherheitsgruppen ermöglichen den IPv6 Datenverkehr an den erforderlichen Ports (normalerweise 443 für HTTPS)
+ Netzwerke ACLs sind so konfiguriert, dass sie IPv6 Datenverkehr zulassen
## Überlegungen zur Migration
Beachten Sie bei der Migration zu IPv6 Endpunkten Folgendes:
+ **Schrittweise Migration**: Sie können Anwendungen schrittweise migrieren, indem Sie URLs jeweils eine Anwendung auf dem Endpunkt aktualisieren.
+ **Netzwerkkompatibilität**: Stellen Sie IPv6 vor der Migration sicher, dass Ihre Netzwerkinfrastruktur dies unterstützt.
+ **Sicherheitsrichtlinien**: Aktualisieren Sie die Sicherheitsgruppenregeln und das Netzwerk ACLs , um bei Bedarf IPv6 Datenverkehr zuzulassen.
+ **Überwachung**: Aktualisieren Sie die Überwachungs- und Protokollierungskonfigurationen, um IPv6 Adressen zu verwalten.
**Anmerkung**
**Datenbankverbindungsadressen**: Wenn IPv6 Endpunkte für die Daten-API verwendet werden, werden in den zugrunde liegenden Datenbankverbindungen und Datenbankprotokollen weiterhin IPv4 Adressen angezeigt. Dieses Verhalten ist zu erwarten und beeinträchtigt nicht die Funktionalität Ihrer IPv6 -fähigen Anwendungen.
## Fehlerbehebung bei IPv6 der Konnektivität
Wenn Sie Probleme mit der IPv6 Konnektivität haben, überprüfen Sie Folgendes:
Netzwerkkonfiguration
Stellen Sie sicher, dass Ihr Netzwerk IPv6 Routing unterstützt IPv6 und ob es richtig konfiguriert ist.
DNS-Auflösung
Stellen Sie sicher, dass Ihr DNS-Resolver AAAA-Datensätze für die Dual-Stack-Endpunkte auflösen kann.
Sicherheitsgruppen
Aktualisieren Sie die Sicherheitsgruppenregeln, um IPv6 Datenverkehr an den erforderlichen Ports zuzulassen (normalerweise 443 für HTTPS).
Client-Bibliotheken
Stellen Sie sicher, dass Ihre HTTP-Clientbibliotheken Dual-Stack-Konnektivität unterstützen IPv6 .
# Einschränkungen der Amazon-RDS-Daten-API
Für die RDS-Daten-API gelten die folgenden Beschränkungen:
+ Sie können Daten-API-Abfragen nur auf Writer-Instances in einem DB-Cluster ausführen. Writer-Instances akzeptieren jedoch sowohl Schreib- als auch Leseanfragen.
+ Bei globalen Aurora-Datenbanken können Sie die Daten-API sowohl auf dem primären als auch auf dem sekundären DB-Cluster aktivieren. Ein sekundärer Cluster hat jedoch erst dann eine Writer-Instance, wenn er zum primären Cluster hochgestuft wurde. Die Daten-API benötigt Zugriff auf die Writer-Instance, um Abfragen verarbeiten zu können. Das gilt sogar für Leseabfragen. Aus diesem Grund schlagen Lese- und Schreibanfragen fehl, die an den sekundären Cluster gesendet werden, solange ihm eine Writer-Instance fehlt. Sobald ein sekundärer Cluster hochgestuft wurde und eine Writer-Instance verfügbar ist, werden Daten-API-Abfragen auf dieser DB-Instance erfolgreich verarbeitet.
+ Die Daten-API wird in T-DB-Instance-Klassen nicht unterstützt.
+ Für Aurora Serverless v2- und bereitgestellte DB-Cluster unterstützt die RDS-Daten-API einige Datentypen nicht. Die Liste der unterstützten Typen finden Sie unter [Vergleich zum Verhalten der Daten-API von Amazon RDS – bei Aurora Serverless v2 und bereitgestellten Clustern und bei Aurora Serverless v1-Clustern](data-api.differences.md).
+ Für Datenbanken mit Aurora PostgreSQL Version 14 und höher unterstützt die Daten-API nur `scram-sha-256` für die Passwortverschlüsselung.
+ Das Limit für Antwortgrößen beträgt 1 MiB. Wenn der Aufruf mehr als 1 MiB an Antwortdaten zurückgibt, wird der Aufruf beendet.
+ Für Aurora Serverless v1 beträgt die maximale Anzahl der Anforderungen pro Sekunde 1 000. Für alle anderen unterstützten Datenbanken gibt es kein Limit.
+ Die Größenbegrenzung der Data-API beträgt 64 KB pro Zeile in der von der Datenbank zurückgegebenen Ergebnismenge. Stellen Sie sicher, dass jede Zeile in einem Ergebnissatz höchstens 64 KB groß ist.
# Vergleich zum Verhalten der Daten-API von Amazon RDS – bei Aurora Serverless v2 und bereitgestellten Clustern und bei Aurora Serverless v1-Clustern
Die neuesten Verbesserungen der Daten-APIs von Amazon RDS machen Daten-APIs für Cluster verfügbar, die aktuelle Versionen von PostgreSQL- oder MySQL-Engines ausführen. Diese Cluster können so konfiguriert werden, dass sie Aurora Serverless v2 verwenden, oder bereitgestellte Instance-Klassen wie `db.r6g` oder `db.r6i`.
In den folgenden Abschnitten werden die Unterschiede beschrieben, die hinsichtlich der Daten-API von Amazon RDS zwischen Aurora Serverless v2 und bereitgestellten DB-Clustern auf der einen Seite und Aurora Serverless v1-DB-Clustern auf der anderen Seite bestehen. Aurora Serverless v1 DB-Cluster verwenden den `serverless`-Engine-Modus. Bereitgestellte DB-Cluster verwenden den `provisioned`-Engine-Modus. Ein Aurora Serverless v2-DB-Cluster verwendet auch den `provisioned`-Engine-Modus und enthält eine oder mehrere Aurora Serverless v2-DB-Instances mit der `db.serverless`-Instance-Klasse.
## Maximale Anzahl von Anforderungen pro Sekunde
**Aurora Serverless v1**
Daten-APIs können bis zu 1 000 Anforderungen pro Sekunde stellen.
**Aurora Serverless v2**
Daten-APIs können eine unbegrenzte Anzahl von Anforderungen pro Sekunde stellen.
## Aktivieren oder Deaktivieren der Daten-API von Amazon RDS in einer vorhandenen Datenbank
**Aurora Serverless v1**
+ **Mit der Amazon-RDS-API**: Verwenden Sie den Vorgang `ModifyCluster` und legen Sie für den Parameter `EnableHttpEndpoint` entweder `True` oder `False` fest.
+ **Mit der AWS CLI**: Verwenden Sie die Operation `modify-db-cluster` mit der Option `--enable-http-endpoint` oder `--no-enable-http-endpoint`.
**Aurora Serverless v2**
+ **Mit der Amazon-RDS-API**: Verwenden Sie die Operationen `EnableHttpEndpoint` und `DisableHttpEndpoint`.
+ **Mit der AWS CLI**: Verwenden Sie die Operationen `enable-http-endpoint` und `disable-http-endpoint`.
## CloudTrail-Ereignisse
**Aurora Serverless v1**
Ereignisse aus Daten-API-Aufrufen sind Verwaltungsereignisse. Diese Ereignisse werden in einem Trail standardmäßig automatisch eingeschlossen. Weitere Informationen finden Sie unter [Daten-API-Ereignisse von einem AWS CloudTrail Trail ausschließen (Aurora Serverless v1nur)](logging-using-cloudtrail-data-api.md#logging-using-cloudtrail-data-api.excluding-cloudtrail-events).
**Aurora Serverless v2**
Ereignisse aus Daten-API-Aufrufen sind Datenereignisse. Diese Ereignisse werden in einem Trail standardmäßig automatisch ausgeschlossen. Weitere Informationen finden Sie unter [Einbeziehen von Daten-API-Ereignissen in einen AWS CloudTrail Trail](logging-using-cloudtrail-data-api.md#logging-using-cloudtrail-data-api.including-cloudtrail-events).
## Unterstützung für mehrere Anweisungen
**Aurora Serverless v1**
+ Mehrere Anweisungen werden für Aurora MySQL nicht unterstützt.
+ Mehrere Anweisungen geben für Aurora PostgreSQL nur die erste Abfrageantwort zurück.
**Aurora Serverless v2**
Mehrere Anweisungen werden nicht unterstützt. Wenn Sie versuchen, mehrere Anweisungen in einem einzigen API-Aufruf auszuführen, wird der Fehler `“An error occurred (ValidationException) when calling the ExecuteStatement operation: Multistatements aren't supported.”` zurückgegeben. Um mehrere Anweisungen auszuführen, nutzen Sie separate `ExecuteStatement`-API-Aufrufe oder `BatchExecuteStatement` für die Stapelverarbeitung.
Das folgende Beispiel zeigt die Fehlermeldung, die ein API-Aufruf zurückgibt, wenn Sie versuchen, mehrere Anweisungen darin auszuführen.
```
aws rds-data execute-statement \
--resource-arn "arn:aws:rds:region:account:cluster:cluster-name" \
--secret-arn "arn:aws:secretsmanager:region:account:secret:secret-name" \
--database "your_database" \
--sql "SELECT * FROM your_table; Select * FROM next_table;
"An error occurred (ValidationException) when calling the ExecuteStatement operation: Multistatements aren't supported.
```
Im folgenden Beispiel werden mehrere Anweisungen mit separaten `ExecuteStatement`-API-Aufrufen ausgeführt.
```
aws rds-data execute-statement \
--resource-arn "arn:aws:rds:region:account:cluster:cluster-name" \
--secret-arn "arn:aws:secretsmanager:region:account:secret:secret-name" \
--database "your_database" \
--sql "SELECT * FROM your_table;"
aws rds-data execute-statement \
--resource-arn "arn:aws:rds:region:account:cluster:cluster-name" \
--secret-arn "arn:aws:secretsmanager:region:account:secret:secret-name" \
--database "your_database" \
--sql "SELECT * FROM next_table;"
```
## Gleichzeitige Anforderungen für dieselbe Transaktions-ID
**Aurora Serverless v1**
Nachfolgende Anforderungen warten, bis die aktuelle Anforderung abgeschlossen ist. Ihre Anwendung muss Zeitüberschreitungsfehler beheben, wenn die Wartezeit zu lang ist.
**Aurora Serverless v2**
Wenn die Daten-API mehrere Anforderungen mit derselben Transaktions-ID erhält, gibt sie sofort diesen Fehler zurück:
`DatabaseErrorException: Transaction is still running a query`
Dieser Fehler tritt in zwei Situationen auf:
+ Ihre Anwendung stellt asynchrone Anforderungen (wie JavaScript-Versprechen) mit derselben Transaktions-ID.
+ Eine frühere Anforderung mit dieser Transaktions-ID wird noch verarbeitet.
Das folgende Beispiel zeigt alle Anforderungen, die parallel zu `promise.all()` ausgeführt werden.
```
const api_calls = [];
for (let i = 0; i < 10; i++) {
api_calls.push(
client.send(
new ExecuteStatementCommand({
...params,
sql: `insert into table_name values (i);`,
transactionId
})
)
);
}
await Promise.all(api_calls);
```
Um diesen Fehler zu beheben, warten Sie, bis die aktuelle Anforderung abgeschlossen ist, bevor Sie eine weitere Anforderung mit derselben Transaktions-ID senden, oder entfernen Sie die Transaktions-ID, um parallele Anforderungen zu ermöglichen.
Das folgende Beispiel zeigt einen API-Aufruf, der die sequentielle Ausführung mit derselben Transaktions-ID verwendet.
```
for (let i = 0; i < 10; i++) {
await client.send(
new ExecuteStatementCommand({
...params,
sql: `insert into table_name values (i);`,
transactionId
})
).promise()
);
}
```
## Wie sich BatchExecuteStatement verhält
Weitere Informationen zu `BatchExecuteStatement` finden Sie unter [BatchExecuteStatement](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BatchExecuteStatement.html).
**Aurora Serverless v1**
Das Objekt für generierte Felder im Aktualisierungsergebnis enthält eingefügte Werte.
**Aurora Serverless v2**
+ Für Aurora MySQL enthält das Objekt für generierte Felder im Aktualisierungsergebnis eingefügte Werte.
+ Für Aurora PostgreSQL bleibt das Objekt für generierte Felder leer.
## Wie sich ExecuteSQL verhält
Weitere Informationen zu `ExecuteSQL` finden Sie unter [ExecuteSQL](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteSql.html).
**Aurora Serverless v1**
Der Vorgang `ExecuteSQL` ist veraltet.
**Aurora Serverless v2**
Der Vorgang `ExecuteSQL` wird nicht unterstützt.
## Wie sich ExecuteStatement verhält
Weitere Informationen zu `ExecuteStatement` finden Sie unter [ExecuteStatement](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html).
**Aurora Serverless v1**
Der Parameter `ExecuteStatement` unterstützt das Abrufen von multidimensionalen Array-Spalten und allen erweiterten Datentypen.
**Aurora Serverless v2**
Der Parameter `ExecuteStatement` unterstützt keine multidimensionalen Array-Spalten. Er unterstützt auch bestimmte PostgreSQL-Datentypen nicht, einschließlich geometrischer und monetärer Typen. Wenn eine Daten-API auf einen nicht unterstützten Datentyp stößt, gibt sie diesen Fehler zurück: `UnsupportedResultException: The result contains the unsupported data type data_type`.
Um dieses Problem zu umgehen, konvertieren Sie den nicht unterstützten Datentyp in `TEXT`. Im folgenden Beispiel wird ein nicht unterstützter Datentyp in `TEXT` konvertiert.
```
SELECT custom_type::TEXT FROM my_table;--
ORSELECT CAST(custom_type AS TEXT) FROM my_table;
```
Eine Liste der unterstützten Datentypen für jede Aurora-Datenbank-Engine finden Sie in der [Referenz zu Daten-API-Vorgängen](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html#data-api-operations).
## Wie sich der Parameter Schema verhält
**Aurora Serverless v1**
Der Parameter `Schema` wird nicht unterstützt. Wenn Sie den Parameter `Schema` in einen API-Aufruf aufnehmen, ignoriert die Daten-API den Parameter.
**Aurora Serverless v2**
Der Parameter `Schema` ist veraltet. Wenn Sie den Parameter `Schema` in einen API-Aufruf aufnehmen, gibt die Daten-API diesen Fehler zurück: `ValidationException: The schema parameter isn't supported`. Im folgenden Beispiel wird ein Daten-API-Aufruf angezeigt, der den Fehler `ValidationException` zurückgibt.
```
aws rds-data execute-statement \
--resource-arn "arn:aws:rds:region:account:cluster:cluster-name" \
--secret-arn "arn:aws:secretsmanager:region:account:secret:secret-name" \
--database "your_database" \
--schema "your_schema" \
--sql "SELECT * FROM your_table LIMIT 10"
```
Um dieses Problem zu lösen, entfernen Sie den Parameter `Schema` aus Ihrem API-Aufruf.
Das folgende Beispiel zeigt einen Daten-API-Aufruf, bei dem der Parameter `Schema` entfernt wurde.
```
aws rds-data execute-statement \
--resource-arn "arn:aws:rds:region:account:cluster:cluster-name" \
--secret-arn "arn:aws:secretsmanager:region:account:secret:secret-name" \
--database "your_database" \
--sql "SELECT * FROM your_table LIMIT 10"
```
# Autorisieren des Zugriffs auf die Amazon-RDS-Daten-API
Benutzer können die Amazon-RDS-Daten-API (Daten-API) nur aufrufen, wenn sie dazu autorisiert sind. Sie können einem Benutzer die Erlaubnis zur Verwendung der Daten-API erteilen, indem Sie eine AWS Identity and Access Management (IAM-) Richtlinie anhängen, die seine Rechte definiert. Sie können die Richtlinie auch einer Rolle anfügen, wenn Sie IAM-Rollen verwenden. Eine AWS verwaltete Richtlinie umfasst Berechtigungen für die Daten-API. `AmazonRDSDataFullAccess`
Die `AmazonRDSDataFullAccess` Richtlinie umfasst auch Berechtigungen, aus denen der Benutzer den Wert eines Geheimnisses abrufen kann AWS Secrets Manager. Benutzer müssen Secrets Manager zum Speichern von Geheimnissen verwenden, die sie in ihren Aufrufen der Daten-API verwenden können. Die Verwendung von Geheimnissen bedeutet, dass Benutzer keine Datenbank-Anmeldeinformationen für die Ressourcen einschließen müssen, die das Ziel ihrer Aufrufe an die Daten-API sind. Die Daten-API ruft Secrets Manager transparent auf, wodurch die Anforderung des Geheimnisses durch den Benutzer zugelassen (oder abgelehnt) wird. Informationen zum Einrichten von Geheimnissen zur Verwendung mit der Daten-API finden Sie unter [Speichern von Datenbankanmeldedaten in AWS Secrets Manager](#data-api.secrets).
Die Richtlinie `AmazonRDSDataFullAccess` ermöglicht den vollständigen Zugriff (über die Daten-API) auf Ressourcen. Sie können den Geltungsbereich einschränken, indem Sie eigene Richtlinien definieren, die den Amazon-Ressourcennamen (ARN) einer Ressource angeben.
Die folgende Richtlinie zeigt beispielsweise ein Beispiel für die Mindestberechtigungen, die ein Benutzer für den Zugriff auf die Daten-API für den durch den ARN identifizierten DB-Cluster benötigt. Die Richtlinie enthält die nötigen Berechtigungen, um auf Secrets Manager zuzugreifen und die Autorisierung für die DB-Instance für den Benutzer zu erhalten.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "SecretsManagerDbCredentialsAccess",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": "arn:aws:secretsmanager:*:*:secret:rds-db-credentials/*"
},
{
"Sid": "RDSDataServiceAccess",
"Effect": "Allow",
"Action": [
"rds-data:BatchExecuteStatement",
"rds-data:BeginTransaction",
"rds-data:CommitTransaction",
"rds-data:ExecuteStatement",
"rds-data:RollbackTransaction"
],
"Resource": "arn:aws:rds:us-east-2:111122223333:cluster:prod"
}
]
}
```
------
Sie sollten für das Element „Ressourcen“ in Ihren Richtlinienanweisungen (wie im Beispiel gezeigt) einen spezifischen ARN anstelle eines Platzhalters (\$1) verwenden.
## Arbeiten mit der Tag-basierten Autorisierung
Die RDS-Daten-API (Daten-API) und Secrets Manager unterstützen beide die Tag-basierte Autorisierung. *Tags* sind Schlüssel-Wert-Paare, die eine Ressource, z. B. einen RDS-Cluster, mit einem zusätzlichen Zeichenfolgenwert kennzeichnen, z. B.
+ `environment:production`
+ `environment:development`
Sie können auf Ihre Ressourcen Tags zum Zweck der Kostenzuweisung, der Ausführungsunterstützung, der Zugriffskontrolle und zu vielen weiteren Zwecken anwenden. (Wenn Sie noch keine Tags für Ihre Ressourcen anwenden und Tags anwenden möchten, finden Sie weitere Informationen unter [Markieren von Amazon-RDS-Ressourcen](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html).) Sie können die Tags in Ihren Richtlinienanweisungen verwenden, um den Zugriff auf die RDS-Cluster einzuschränken, die mit diesen Tags gekennzeichnet sind. Ein Aurora-DB-Cluster könnte beispielsweise Tags besitzen, die die Umgebung als Produktions- oder Entwicklungsumgebung kennzeichnen.
Das folgende Beispiel zeigt, wie Sie in Ihren Richtlinienanweisungen Tags verwenden können. Diese Anweisung erfordert, dass sowohl der Cluster als auch der in der Daten-API-Anforderung übergebene Schlüssel das Tag `environment:production` enthalten.
So wird die Richtlinie angewendet: Wenn ein Benutzer einen Aufruf über die Daten-API ausführt, wird die Anforderung an den Service gesendet. Die Daten-API überprüft zunächst, ob der in der Anforderung übergebene Cluster-ARN mit `environment:production` markiert ist. Anschließend wird Secrets Manager aufgerufen, um den Wert des Geheimnisses des Benutzers in der Anforderung abzurufen. Secrets Manager überprüft auch, ob das Geheimnis des Benutzers mit `environment:production` markiert ist. Wenn ja, verwendet die Daten-API den abgerufenen Wert für das DB-Passwort des Benutzers. Wenn dieser ebenfalls korrekt ist, wird die Daten-API-Anforderung für den Benutzer erfolgreich aufgerufen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "SecretsManagerDbCredentialsAccess",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": "arn:aws:secretsmanager:*:*:secret:rds-db-credentials/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/environment": [
"production"
]
}
}
},
{
"Sid": "RDSDataServiceAccess",
"Effect": "Allow",
"Action": [
"rds-data:*"
],
"Resource": "arn:aws:rds:us-east-2:111122223333:cluster:*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/environment": [
"production"
]
}
}
}
]
}
```
------
Das Beispiel zeigt separate Aktionen für `rds-data` und `secretsmanager` für die Daten-API und Secrets Manager. Sie können jedoch Aktionen kombinieren und Tag-Bedingungen auf viele verschiedene Arten definieren, um Ihre spezifischen Anwendungsfälle zu unterstützen. Weitere Informationen finden Sie unter [Verwenden identitätsbasierter Richtlinien (IAM-Richtlinien) für Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access_identity-based-policies.html#permissions_grant-limited-condition).
Im Element „Bedingung“ der Richtlinie können Sie Tag-Schlüssel aus den folgenden Optionen auswählen:
+ `aws:TagKeys`
+ `aws:ResourceTag/${TagKey}`
Weitere Informationen zu Ressourcen-Tags und deren Verwendung `aws:TagKeys` finden Sie unter [Steuern des Zugriffs auf AWS Ressourcen mithilfe von Ressourcen-Tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html#access_tags_control-tag-keys).
**Anmerkung**
Sowohl Daten-API als auch AWS Secrets Manager autorisierte Benutzer. Wenn Sie nicht für alle in einer Richtlinie definierten Aktionen Berechtigungen besitzen, erhalten Sie den Fehler `AccessDeniedException`.
## Speichern von Datenbankanmeldedaten in AWS Secrets Manager
Wenn Sie die Daten-API von Amazon RDS (Daten-API) aufrufen, können Sie die Anmeldeinformationen für die Datenbank unter Verwendung eines Geheimnisses in Secrets Manager übergeben. Zum Übermitteln der Anmeldeinformationen auf diese Weise geben Sie den Namen des Secrets oder den Amazon-Ressourcennamen (ARN) des Secrets an.
**So speichern Sie DB-Cluster-Anmeldeinformationen in einem Secret**
1. Sie können in Secrets Manager einen geheimen Schlüssel erstellen, der Anmeldeinformationen für den Aurora-DB-Cluster enthält.
Anweisungen finden Sie unter [Erstellen eines Datenbank-Secrets](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html) im *AWS Secrets Manager -Benutzerhandbuch*.
1. Verwenden Sie die Secrets Manager 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 sie in Aufrufen an die Daten-API verwenden.
Weitere Informationen zur Verwendung von Secrets Manager finden Sie im [AWS Secrets-Manager-Benutzerhandbuch](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html).
Informationen dazu, wie Amazon Aurora die Identitäts- und Zugriffsverwaltung steuert, finden Sie unter [So funktioniert Amazon Aurora mit IAM](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/security_iam_service-with-iam.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) im *IAM-Benutzerhandbuch*. Informationen zum Hinzufügen einer IAM-Richtlinie zu einem Benutzer finden Sie im Abschnitt [Hinzufügen und Entfernen von IAM-Identitätsberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) im *IAM-Benutzerhandbuch*.
# Aktivieren der Amazon-RDS-Daten-API
Um die Amazon-RDS-Daten-API (Daten-API) nutzen zu können, müssen Sie sie für Ihren Aurora-DB-Cluster aktivieren. Sie können die Daten-API aktivieren, wenn Sie den DB-Cluster erstellen oder ändern.
**Anmerkung**
Ob die Daten-API für Ihren Cluster verfügbar ist, hängt von Ihrer Aurora-Version, Datenbank-Engine und AWS Region ab. Für ältere Aurora-Versionen funktioniert die Daten-API nur mit Aurora Serverless v1-Clustern. Bei neueren Aurora-Versionen funktioniert die Daten-API mit Clustern, die sowohl bereitgestellte als auch Aurora Serverless v2-Instances verwenden. Informationen dazu, ob Ihr Cluster die Daten-API verwenden kann, finden Sie unter [Unterstützte Regionen und Aurora-DB-Engines für RDS-Daten-API](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.md).
**Topics**
+ [
## Aktivieren der RDS-Daten-API beim Erstellen einer Datenbank
](#data-api.enabling.creating)
+ [
## Aktivieren der RDS-Daten-API in einer vorhandenen Datenbank
](#data-api.enabling.modifying)
## Aktivieren der RDS-Daten-API beim Erstellen einer Datenbank
Während Sie eine Datenbank erstellen, die die RDS-Daten-API (Daten-API) unterstützt, können Sie dieses Feature aktivieren. In den folgenden Verfahren wird beschrieben, wie Sie dies tun, wenn Sie die AWS-Managementkonsole AWS CLI, oder die RDS-API verwenden.
### Konsole
Um die Daten-API bei der Erstellung eines DB-Clusters zu aktivieren, wählen Sie das Kontrollkästchen **RDS-Daten-API aktivieren** im Bereich **Konnektivität** der Seite **Datenbank erstellen** aus, wie im folgenden Screenshot gezeigt.
![\[Der Abschnitt „Konnektivität“ auf der Seite „Datenbank erstellen“ mit ausgewähltem Kontrollkästchen „RDS-Daten-API aktivieren“.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/data-api-enable-on-create.png)
Anleitungen zum Erstellen eines Aurora-DB-Clusters, der die RDS-Daten-API nutzen kann, finden Sie unten:
+ Für Aurora Serverless v2 und bereitgestellte Cluster – [Erstellen eines Amazon Aurora-DB Clusters](Aurora.CreateInstance.md)
+ Für Aurora Serverless v1 – [Erstellen eines Aurora Serverless v1-DB Clusters](aurora-serverless.create.md)
### AWS CLI
Um die Daten-API zu aktivieren, während Sie einen Aurora-DB-Cluster erstellen, führen Sie den [create-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html) AWS CLI Befehl mit der `--enable-http-endpoint` Option aus.
Im folgenden Beispiel wird ein DB-Cluster von Aurora PostgreSQL mit aktivierter Daten-API erstellt.
Für Linux, macOS oder Unix:
```
aws rds create-db-cluster \
--db-cluster-identifier my_pg_cluster \
--engine aurora-postgresql \
--enable-http-endpoint
```
Für Windows:
```
aws rds create-db-cluster ^
--db-cluster-identifier my_pg_cluster ^
--engine aurora-postgresql ^
--enable-http-endpoint
```
### RDS-API
Um die Daten-API zu aktivieren, während Sie einen Aurora-DB-Cluster [erstellen, verwenden Sie die DBCluster Operation Create](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html), wobei der Wert des `EnableHttpEndpoint` Parameters auf gesetzt ist`true`.
## Aktivieren der RDS-Daten-API in einer vorhandenen Datenbank
Sie können einen DB-Cluster ändern, der die RDS-Daten-API (Daten-API) unterstützt, um dieses Feature zu aktivieren oder zu deaktivieren.
**Topics**
+ [
### Aktivieren oder Deaktivieren der Daten-API (Aurora Serverless v2 und bereitgestellt)
](#data-api.enabling.modifying.all)
+ [
### Aktivieren oder Deaktivieren der Daten-API (nur Aurora Serverless v1)
](#data-api.enabling.modifying.sv1)
### Aktivieren oder Deaktivieren der Daten-API (Aurora Serverless v2 und bereitgestellt)
Verwenden Sie die folgenden Verfahren, um die Daten-API in Aurora Serverless v2 und bereitgestellten Datenbanken zu aktivieren oder zu deaktivieren. Verwenden Sie die Verfahren unter [Aktivieren oder Deaktivieren der Daten-API (nur Aurora Serverless v1)](#data-api.enabling.modifying.sv1), um die Daten-API in Aurora Serverless v1-Datenbanken zu aktivieren oder zu deaktivieren.
#### Konsole
Sie können die Daten-API aktivieren oder deaktivieren, indem Sie die RDS-Konsole für einen DB-Cluster verwenden, der dieses Feature unterstützt. Öffnen Sie dazu die Cluster-Detailseite der Datenbank, für die Sie die Daten-API aktivieren oder deaktivieren möchten, und wechseln Sie auf der Registerkarte **Konnektivität und Sicherheit** zum Abschnitt **RDS-Daten-API**. In diesem Abschnitt wird der Status der Daten-API angezeigt und Sie können sie aktivieren oder deaktivieren.
Der folgende Screenshot zeigt, dass die **RDS-Daten-API** nicht aktiviert ist.
![\[Der Abschnitt „RDS-Daten-API“ auf der Registerkarte „Konnektivität und Sicherheit“ der Detailseite für einen DB-Cluster. Der Status der Daten-API wird als deaktiviert angezeigt, und die Schaltfläche „RDS-Daten-API aktivieren“ ist vorhanden.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/data-api-enable-from-details.png)
#### AWS CLI
Um die Daten-API in einer vorhandenen Datenbank zu aktivieren oder zu deaktivieren, führen Sie den [disable-http-endpoint](https://docs.aws.amazon.com/cli/latest/reference/rds/disable-http-endpoint.html) AWS CLI Befehl [enable-http-endpoint](https://docs.aws.amazon.com/cli/latest/reference/rds/enable-http-endpoint.html)or aus und geben Sie den ARN Ihres DB-Clusters an.
Das folgende Beispiel aktiviert die Daten-API.
Für Linux, macOS oder Unix:
```
aws rds enable-http-endpoint \
--resource-arn cluster_arn
```
Für Windows:
```
aws rds enable-http-endpoint ^
--resource-arn cluster_arn
```
#### RDS-API
Verwenden Sie die [DisableHttpEndpoint](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DisableHttpEndpoint.html)Operationen [EnableHttpEndpoint](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_EnableHttpEndpoint.html)und, um die Daten-API in einer vorhandenen Datenbank zu aktivieren oder zu deaktivieren.
### Aktivieren oder Deaktivieren der Daten-API (nur Aurora Serverless v1)
Verwenden Sie die folgenden Verfahren, um die Daten-API in vorhandenen Aurora Serverless v1-Datenbanken zu aktivieren oder zu deaktivieren. Verwenden Sie die Verfahren unter [Aktivieren oder Deaktivieren der Daten-API (Aurora Serverless v2 und bereitgestellt)](#data-api.enabling.modifying.all), um die Daten-API für Aurora Serverless v2- und bereitgestellte Datenbanken zu aktivieren oder zu deaktivieren.
#### Konsole
Wenn Sie einen Aurora Serverless v1-DB-Cluster bearbeiten, aktivieren Sie die Daten-API im Abschnitt **Konnektivität** der RDS-Konsole.
Der folgende Screenshot zeigt die aktivierte **Daten-API** beim Ändern eines Aurora-DB-Clusters.
![\[Im Abschnitt „Konnektivität“ auf der Seite „DB-Cluster ändern“ ist das Kontrollkästchen „Daten-API“ aktiviert.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/data-api-modify-serverlessv1.png)
Anleitungen zum Ändern eines Aurora Serverless v1-DB-Clusters finden Sie unter [Ändern eines Aurora Serverless v1-DB-Clusters](aurora-serverless.modifying.md).
#### AWS CLI
Um die Daten-API zu aktivieren oder zu deaktivieren, führen Sie den [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) AWS CLI Befehl gegebenenfalls mit `--enable-http-endpoint` oder `--no-enable-http-endpoint` aus.
Im folgenden Beispiel wird die Daten-API in einem `sample-cluster` aktiviert.
Für Linux, macOS oder Unix:
```
aws rds modify-db-cluster \
--db-cluster-identifier sample-cluster \
--enable-http-endpoint
```
Für Windows:
```
aws rds modify-db-cluster ^
--db-cluster-identifier sample-cluster ^
--enable-http-endpoint
```
#### RDS-API
Um die Daten-API zu aktivieren, verwenden [Sie den DBCluster Vorgang Ändern](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) und setzen Sie den Wert von `true` je `EnableHttpEndpoint` nach `false` Bedarf auf oder.
# Erstellen eines Amazon-VPC-Endpunkts für die Amazon-RDS-Daten-API (AWS PrivateLink)
Amazon VPC ermöglicht es Ihnen, AWS Ressourcen wie Aurora-DB-Cluster und -Anwendungen in einer Virtual Private Cloud (VPC) zu starten. AWS PrivateLink bietet private Konnektivität zwischen VPCs und AWS Diensten mit hoher Sicherheit im Amazon-Netzwerk. Mithilfe AWS PrivateLink können Sie Amazon 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 über AWS PrivateLink finden Sie unter [VPC-Endpunktservices (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-service.html) im *Amazon-Virtual-Private-Cloud-Benutzerhandbuch*.
Sie können die RDS-Daten-API (Daten-API) mit Amazon-VPC-Endpunkten aufrufen. Durch die Verwendung eines Amazon VPC-Endpunkts wird der Datenverkehr zwischen Anwendungen in Ihrer Amazon VPC und der Daten-API im AWS Netzwerk aufrechterhalten, 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 sie enthalten VPCs , 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 für **Servicename** **rds-data** aus.
![\[Erstellen eines Amazon-VPC-Endpunkts für die Daten-API\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/data-api-create-endpoint.png)
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.
![\[Auswählen der Subnetze für den Amazon VPC-Endpunkt\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/data-api-vpc-endpoint-subnets.png)
Um einen Amazon VPC-Endpunkt zu erstellen, geben Sie den privaten IP-Adressbereich an, in dem auf den Endpunkt zugegriffen werden soll. 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.
![\[Aktivieren des DNS-Namens für den Amazon VPC-Endpunkt\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/data-api-vpc-endpoint-enable-endpoint.png)
Private DNS löst den standardmäßigen DNS-Hostnamen der Daten-API (`https://rds-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 VPC-Endpunkt der Daten-API zugreifen, AWS SDKs ohne Code AWS CLI - oder Konfigurationsänderungen vorzunehmen, um die Endpunkt-URL der Daten-API 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 unter **Richtlinie** die Option **Voller Zugriff** aus, damit jeder innerhalb der Amazon VPC über diesen Endpunkt auf die Daten-API zugreifen kann. Oder wählen Sie **Benutzerdefiniert** aus, um eine Richtlinie anzugeben, die den Zugriff einschränkt.
Wenn Sie **Benutzerdefiniert** auswählen, geben Sie die Richtlinie im Tool zur Richtlinienerstellung ein.
1. Wählen Sie **Endpunkt erstellen** aus.
Nachdem der Endpunkt erstellt wurde, wählen Sie den Link in, AWS-Managementkonsole um die Endpunktdetails anzuzeigen.
![\[Link zu den Amazon VPC-Endpunktdetails\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/data-api-vpc-endpoint-link-to-details.png)
Auf der Registerkarte **Details** des Endpunkts werden die DNS-Hostnamen angezeigt, die beim Erstellen des Amazon VPC-Endpunkts generiert wurden.
![\[Link zu den Amazon VPC-Endpunktdetails\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/images/data-api-vpc-endpoint-dns-names.png)
Sie können den Standardendpunkt (`rds-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 [Aufrufen der Daten-API von Amazon RDS](data-api.calling.md).
# Aufrufen der Daten-API von Amazon RDS
Wenn die Daten-API von Amazon RDS (Daten-API) auf Ihrem Aurora-DB-Cluster aktiviert ist, können Sie SQL-Anweisungen auf dem Aurora-DB-Cluster ausführen, indem Sie die Daten-API oder die AWS CLI verwenden. Die Daten-API unterstützt die von den AWS SDKs unterstützten Programmiersprachen. Weitere Informationen finden Sie unter [Tools für AWS](https://aws.amazon.com/tools/).
**Topics**
+ [
# Referenz zu Operationen mit der Amazon-RDS-Daten-API
](data-api-operations.md)
+ [
# Aufrufen der Daten-API von Amazon RDS über die AWS CLI
](data-api.calling.cli.md)
+ [
# Aufrufen der Daten-API von Amazon RDS aus einer Python-Anwendung
](data-api.calling.python.md)
+ [
# Aufrufen der Daten-API von Amazon RDS aus einer Java-Anwendung
](data-api.calling.java.md)
+ [
# Steuern des Timeout-Verhaltens der Daten-API
](data-api-timeouts.md)
# Referenz zu Operationen mit der Amazon-RDS-Daten-API
Die Amazon-RDS-Daten-API bietet die folgenden Operationen zur Ausführung von SQL-Anweisungen.
****
| Daten-API-Operation | AWS CLI Befehl | Description |
| --- | --- | --- |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/execute-statement.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/execute-statement.html) | Führt eine SQL-Anweisung in einer Datenbank aus. |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BatchExecuteStatement.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/batch-execute-statement.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/batch-execute-statement.html) | Führt eine Batch-SQL-Anweisung über ein Array von Daten für Massen-Update- und -Einfügeoperationen aus. Sie können eine DML-Anweisung (Data Manipulation Language) mit einem Array von Parametersätzen ausführen. Eine Batch-SQL-Anweisung kann gegenüber einzelnen Einfügungs- und Aktualisierungsanweisungen eine erhebliche Leistungsverbesserung bieten. |
Sie können beide Vorgänge verwenden, um einzelne SQL-Anweisungen oder Transaktionen auszuführen. Für Transaktionen bietet die Daten-API die folgenden Operationen.
****
| Daten-API-Operation | AWS CLI Befehl | Description |
| --- | --- | --- |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BeginTransaction.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BeginTransaction.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/begin-transaction.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/begin-transaction.html) | Startet eine SQL-Transaktion. |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_CommitTransaction.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_CommitTransaction.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/commit-transaction.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/commit-transaction.html) | Beendet eine SQL-Transaktion und schreibt die Änderungen fest. |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_RollbackTransaction.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_RollbackTransaction.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/rollback-transaction.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/rollback-transaction.html) | Führt ein Rollback einer Transaktion durch. |
Die Operationen zur Ausführung von SQL-Anweisungen und zur Unterstützung von Transaktionen haben die folgenden gemeinsamen Daten-API-Parameter und AWS CLI -Optionen. Einige Operationen unterstützen andere Parameter oder Optionen.
****
| Daten-API-Operationsparameter | AWS CLI Befehlsoption | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `resourceArn` | `--resource-arn` | Ja | Der Amazon-Ressourcenname (ARN) für den Aurora-DB-Cluster. Der Cluster muss sich in derselben AWS-Konto IAM-Rolle oder dem IAM-Benutzer befinden, der die Daten-API aufruft. Um auf einen Cluster in einem anderen Konto zuzugreifen, nehmen Sie eine Rolle in diesem Konto an. |
| `secretArn` | `--secret-arn` | Ja | Der Name oder ARN des Secrets, das Zugriff auf das DB-Cluster ermöglicht. |
Die RDS-Daten-API unterstützt die folgenden Datentypen für Aurora MySQL:
+ `TINYINT(1)`, `BOOLEAN`, `BOOL`
+ `TINYINT`
+ `SMALLINT` [`SIGNED` \$1 `UNSIGNED`]
+ `MEDIUMINT` [`SIGNED` \$1 `UNSIGNED`]
+ `INT` [`SIGNED` \$1 `UNSIGNED`]
+ `BIGINT` [`SIGNED` \$1 `UNSIGNED`]
+ `FLOAT`
+ `DOUBLE`
+ `VARCHAR`, `CHAR`, `TEXT`, `ENUM`
+ `VARBINARY`, `BINARY`, `BLOB`
+ `DATE`, `TIME`, `DATETIME`, `TIMESTAMP`
+ `DECIMAL`
+ `JSON`
+ `BIT`, `BIT(N)`
Die RDS-Daten-API unterstützt die folgenden skalaren Typen für Aurora-PostgreSQL:
+ `BOOL`
+ `BYTEA`
+ `DATE`
+ `CIDR`
+ `DECIMAL`, `NUMERIC`
+ `ENUM`
+ `FLOAT8`, `DOUBLE PRECISION`
+ `INET`
+ `INT`, `INT4`, `SERIAL`
+ `INT2`, `SMALLINT`, `SMALLSERIAL`
+ `INT8`, `BIGINT`, `BIGSERIAL`
+ `JSONB`, `JSON`
+ `REAL`, `FLOAT`
+ `TEXT`, `CHAR(N)`, `VARCHAR`, `NAME`
+ `TIME`
+ `TIMESTAMP`
+ `UUID`
+ `VECTOR`
Die RDS-Daten-API unterstützt die folgenden Array-Typen für Aurora PostgreSQL:
+ `BOOL[]`, `BIT[]`
+ `DATE[]`
+ `DECIMAL[]`, `NUMERIC[]`
+ `FLOAT8[]`, `DOUBLE PRECISION[]`
+ `INT[]`, `INT4[]`
+ `INT2[]`
+ `INT8[]`, `BIGINT[]`
+ `JSON[]`
+ `REAL[]`, `FLOAT[]`
+ `TEXT[]`, `CHAR(N)[]`, `VARCHAR[]`, `NAME[]`
+ `TIME[]`
+ `TIMESTAMP[]`
+ `UUID[]`
Sie können Parameter in Daten-API-Aufrufen an `ExecuteStatement` und und verwenden`BatchExecuteStatement`, wenn Sie die AWS CLI Befehle `execute-statement` und ausführen. `batch-execute-statement` Um einen Parameter zu verwenden, geben Sie ein Name-Wert-Paar im Datentyp `SqlParameter` an. Den Wert geben Sie mit dem Datentyp `Field` an. 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, TINYINT, SMALLINT, BIGINT` | `LONG` (oder `STRING`) |
| `FLOAT, REAL, DOUBLE` | `DOUBLE` |
| `DECIMAL` | `STRING` |
| `BOOLEAN, BIT` | `BOOLEAN` |
| `BLOB, BINARY, LONGVARBINARY, VARBINARY` | `BLOB` |
| `CLOB` | `STRING` |
| Andere Typen (einschließlich datums- und zeitbezogener Typen) | `STRING` |
**Anmerkung**
Sie können den Datentyp `LONG` oder `STRING` in Ihrem Daten-API-Aufruf für von der Datenbank zurückgegebene `LONG`-Werte angeben. Wir empfehlen Ihnen, dies zu tun, um zu vermeiden, dass bei extrem großen Zahlen die Genauigkeit verloren geht, was bei der Arbeit mit auftreten kann JavaScript.
Bestimmte Typen, wie `DECIMAL` und `TIME`, erfordern einen Hinweis, damit die Daten-API `String`-Werte als richtigen Typ an die Datenbank weiterleitet. Um einen Hinweis zu verwenden, schließen Sie Werte für `typeHint` in den Datentyp `SqlParameter` ein. Die folgenden Werte sind für `typeHint` möglich:
+ `DATE` – Der entsprechende `String`-Parameter wird als Objekt des Typs `DATE` an die Datenbank gesendet. Das akzeptierte Format ist `YYYY-MM-DD`.
+ `DECIMAL` – Der entsprechende `String`-Parameter wird als Objekt des Typs `DECIMAL` an die Datenbank gesendet.
+ `JSON` – Der entsprechende `String`-Parameter wird als Objekt des Typs `JSON` an die Datenbank gesendet.
+ `TIME` – Der entsprechende `String`-Parameter wird als Objekt des Typs `TIME` an die Datenbank gesendet. Das akzeptierte Format ist `HH:MM:SS[.FFF]`.
+ `TIMESTAMP` – Der entsprechende `String`-Parameter wird als Objekt des Typs `TIMESTAMP` an die Datenbank gesendet. Das akzeptierte Format ist `YYYY-MM-DD HH:MM:SS[.FFF]`.
+ `UUID` – Der entsprechende `String`-Parameter wird als Objekt des Typs `UUID` an die Datenbank gesendet.
**Anmerkung**
Derzeit unterstützt die Daten-API keine Arrays von Universal Unique Identifiers ()UUIDs.
**Anmerkung**
Für Amazon Aurora PostgreSQL gibt die Daten-API immer den Aurora PostgreSQL Datentyp `TIMESTAMPTZ` in der UTC-Zeitzone zurück.
# Aufrufen der Daten-API von Amazon RDS über die AWS CLI
Sie können die RDS-Daten-API (Daten-API) über die AWS CLI aufrufen.
In den folgenden Beispielen wird die AWS CLI für die Daten-API verwendet. Weitere Informationen finden Sie in der [AWS CLI-Referenz für die Daten-API](https://docs.aws.amazon.com/cli/latest/reference/rds-data/index.html).
Ersetzen Sie in jedem Beispiel den Amazon-Ressourcennamen (ARN) des DB-Clusters durch den ARN Ihres Aurora-DB-Clusters. Ersetzen Sie außerdem den geheimen ARN durch den ARN des geheimen Schlüssels in Secrets Manager, der den Zugriff auf den DB-Cluster ermöglicht.
**Anmerkung**
Die AWS CLI kann Antworten in JSON formatieren.
**Topics**
+ [
## Starten einer SQL-Transaktion
](#data-api.calling.cli.begin-transaction)
+ [
## Ausführen einer SQL-Anweisung
](#data-api.calling.cli.execute-statement)
+ [
## Ausführen einer Stapel-SQL-Anweisung über ein Daten-Array
](#data-api.calling.cli.batch-execute-statement)
+ [
## Übergeben einer SQL-Transaktion
](#data-api.calling.cli.commit-transaction)
+ [
## Rollback einer SQL-Transaktion
](#data-api.calling.cli.rollback-transaction)
## Starten einer SQL-Transaktion
Sie können eine SQL-Transaktion mit dem CLI-Befehl `aws rds-data begin-transaction` starten. Der Aufruf gibt eine Transaktions-ID zurück.
**Wichtig**
Auf der Daten-API kommt es bei einer Transaktion zu einer Zeitüberschreitung, wenn es innerhalb von drei Minuten keine Aufrufe gibt, die ihre Transaktions-ID verwenden. Wenn es zu einer Zeitüberschreitung kommt, bevor die Transaktion festgeschrieben wird, setzt die Daten-API die Transaktion automatisch zurück.
MySQL Data Definition Language (DDL)-Anweisungen innerhalb einer Transaktion führen zu einem impliziten Commit. Wir empfehlen Ihnen, die einzelnen MySQL-DDL-Anweisungen jeweils in einem separaten Befehl `execute-statement` mit der Option `--continue-after-timeout` auszuführen.
Geben Sie zusätzlich zu den allgemeinen Optionen die Option `--database` an, die den Namen der Datenbank enthält.
Der folgende CLI-Befehl beispielsweise startet eine SQL-Transaktion.
Für Linux, macOS oder Unix:
```
aws rds-data begin-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret"
```
Für Windows:
```
aws rds-data begin-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"transactionId": "ABC1234567890xyz"
}
```
## Ausführen einer SQL-Anweisung
Sie können mittels des CLI-Befehls `aws rds-data execute-statement` eine SQL-Anweisung ausführen.
Sie können die SQL-Anweisung in einer Transaktion ausführen, indem Sie die Transaktions-ID mit der Option `--transaction-id` angeben. Sie können eine SQL-Transaktion mit dem CLI-Befehl `aws rds-data begin-transaction` starten. Sie können eine Transaktion beenden und übergeben, indem Sie den CLI-Befehl `aws rds-data commit-transaction` verwenden.
**Wichtig**
Wenn Sie die Option `--transaction-id` nicht angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Geben Sie zusätzlich zu den allgemeinen Optionen die folgenden Optionen an:
+ `--sql` (erforderlich) – eine SQL-Anweisung, die auf dem DB-Cluster ausgeführt werden soll.
+ `--transaction-id` (optional) – die ID einer Transaktion, die über den CLI-Befehl `begin-transaction` gestartet wurde. Geben Sie die Transaktions-ID der Transaktion an, in die Sie die SQL-Anweisung einfügen möchten.
+ `--parameters` (optional) – die Parameter für die SQL-Anweisung.
+ `--include-result-metadata | --no-include-result-metadata` (optional) – ein Wert, der angibt, ob Metadaten in die Ergebnisse eingefügt werden sollen. Der Standardwert ist `--no-include-result-metadata`.
+ `--database` (optional) – der Name der Datenbank.
Die `--database`-Option funktioniert möglicherweise nicht, wenn Sie eine SQL-Anweisung ausführen, nachdem Sie bei der vorherige Anfrage `--sql "use database_name;"` ausgeführt haben. Es wird empfohlen, die `--database`-Option zu verwenden statt `--sql "use database_name;"`-Anweisungen auszuführen.
+ `--continue-after-timeout | --no-continue-after-timeout` (optional) – ein Wert, der angibt, ob die Anweisung weiter ausgeführt werden soll, wenn der Aufruf das Daten-API-Zeitintervall von 45 Sekunden überschreitet. Der Standardwert ist `--no-continue-after-timeout`.
Im Fall von Data Definition Language (DDL)-Anweisungen sollten Sie die Anweisung nach Ablauf des Aufrufs weiter ausführen, um Fehler und die Möglichkeit beschädigter Datenstrukturen zu vermeiden.
+ `--format-records-as "JSON"|"NONE"` – Ein optionaler Wert, der angibt, ob die Ergebnismenge als JSON-Zeichenfolge formatiert werden soll. Der Standardwert ist `"NONE"`. Nutzungsinformationen über die Verarbeitung von JSON-Ergebnismengen finden Sie unter [Verarbeiten von Abfrageergebnissen der Amazon-RDS-Data-API im JSON-Format](data-api-json.md).
Das DB-Cluster gibt für den Aufruf eine Antwort zurück.
**Anmerkung**
Das Limit für Antwortgrößen beträgt 1 MiB. Wenn der Aufruf mehr als 1 MiB an Antwortdaten zurückgibt, wird der Aufruf beendet.
Für Aurora Serverless v1 beträgt die maximale Anzahl der Anforderungen pro Sekunde 1 000. Für alle anderen unterstützten Datenbanken gibt es kein Limit.
Der folgende CLI-Befehl führt beispielsweise eine einzelne SQL-Anweisung aus und lässt die Metadaten in den Ergebnissen weg (Standard).
Für Linux, macOS oder Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "select * from mytable"
```
Für Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "select * from mytable"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"numberOfRecordsUpdated": 0,
"records": [
[
{
"longValue": 1
},
{
"stringValue": "ValueOne"
}
],
[
{
"longValue": 2
},
{
"stringValue": "ValueTwo"
}
],
[
{
"longValue": 3
},
{
"stringValue": "ValueThree"
}
]
]
}
```
Der folgende CLI-Befehl führt eine einzelne SQL-Anweisung in einer Transaktion aus, indem die Option `--transaction-id` angegeben wird.
Für Linux, macOS oder Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "update mytable set quantity=5 where id=201" --transaction-id "ABC1234567890xyz"
```
Für Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "update mytable set quantity=5 where id=201" --transaction-id "ABC1234567890xyz"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"numberOfRecordsUpdated": 1
}
```
Der folgende CLI-Befehl führt eine einzelne SQL-Anweisung mit Parametern aus.
Für Linux, macOS oder Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "insert into mytable values (:id, :val)" --parameters "[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"value1\"}}]"
```
Für Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "insert into mytable values (:id, :val)" --parameters "[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"value1\"}}]"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"numberOfRecordsUpdated": 1
}
```
Der folgende CLI-Befehl führt eine Data Definition Language (DDL)-SQL-Anweisung aus. Die DDL-Anweisung benennt die Spalte `job` in die Spalte `role` um.
**Wichtig**
Im Fall von DDL-Anweisungen sollten Sie die Anweisung auch nach Ablauf des Aufrufs weiter ausführen. Wenn eine DDL-Anweisung vor Ende der Ausführung beendet wird, kann dies zu Fehlern und möglicherweise beschädigten Datenstrukturen führen. Um eine Anweisung weiter auszuführen, nachdem ein Aufruf das für die RDS-Daten-API geltende Zeitintervall von 45 Sekunden überschritten hat, geben Sie die Option `--continue-after-timeout` an.
Für Linux, macOS oder Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "alter table mytable change column job role varchar(100)" --continue-after-timeout
```
Für Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "alter table mytable change column job role varchar(100)" --continue-after-timeout
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"generatedFields": [],
"numberOfRecordsUpdated": 0
}
```
**Anmerkung**
Die `generatedFields`-Daten werden von Aurora PostgreSQL nicht unterstützt. Zum Abrufen der Werte von generierten Feldern verwenden Sie die `RETURNING`-Klausel. Weitere Informationen finden Sie in unter [ Returning Data From Modified Rows](https://www.postgresql.org/docs/10/dml-returning.html) in der PostgreSQL-Dokumentation.
## Ausführen einer Stapel-SQL-Anweisung über ein Daten-Array
Sie können eine Batch-SQL-Anweisung über ein Daten-Array ausführen, indem Sie den CLI-Befehl `aws rds-data batch-execute-statement` verwenden. Sie können dieses Befehl verwenden, um einen Massenimport oder eine Update-Operation auszuführen.
Sie können die SQL-Anweisung in einer Transaktion ausführen, indem Sie die Transaktions-ID mit der Option `--transaction-id` angeben. Sie können eine SQL-Transaktion mit dem CLI-Befehl `aws rds-data begin-transaction` starten. Sie können eine Transaktion mit dem CLI-Befehl `aws rds-data commit-transaction` beenden und übergeben.
**Wichtig**
Wenn Sie die Option `--transaction-id` nicht angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Geben Sie zusätzlich zu den allgemeinen Optionen die folgenden Optionen an:
+ `--sql` (erforderlich) – eine SQL-Anweisung, die auf dem DB-Cluster ausgeführt werden soll.
**Tipp**
Fügen Sie bei MySQL-kompatiblen Anweisungen kein Semikolon am Ende des `--sql`-Parameters ein. Ein abschließendes Semikolon kann einen Syntaxfehler verursachen.
+ `--transaction-id` (optional) – die ID einer Transaktion, die über den CLI-Befehl `begin-transaction` gestartet wurde. Geben Sie die Transaktions-ID der Transaktion an, in die Sie die SQL-Anweisung einfügen möchten.
+ `--parameter-set` (optional) – die Parametersätze für die Batch-Operation.
+ `--database` (optional) – der Name der Datenbank.
Das DB-Cluster gibt für den Aufruf eine Antwort zurück.
**Anmerkung**
Es gibt keine feste Obergrenze für die Anzahl der Parametersätze. Die maximale Größe der HTTP-Anforderung, die über die Daten-API gesendet wird, beträgt jedoch 4 MiB. Wenn die Anforderung dieses Limit überschreitet, gibt die Daten-API einen Fehler zurück und die Anfrage wird nicht verarbeitet. Dieses 4-MiB-Limit umfasst die Größe der HTTP-Header und der JSON-Notation in der Anforderung. Die Anzahl der Parametersätze, die Sie einbinden können, hängt demnach von mehreren Faktoren ab, z. B. von der Größe der SQL-Anweisung und der Größe der individuellen Parametersätze.
Das Limit für Antwortgrößen beträgt 1 MiB. Wenn der Aufruf mehr als 1 MiB an Antwortdaten zurückgibt, wird der Aufruf beendet.
Für Aurora Serverless v1 beträgt die maximale Anzahl der Anforderungen pro Sekunde 1 000. Für alle anderen unterstützten Datenbanken gibt es kein Limit.
Der folgende CLI-Befehl führt beispielsweise eine Batch-SQL-Anweisung für ein Daten-Array mit einem Parametersatz aus.
Für Linux, macOS oder Unix:
```
aws rds-data batch-execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "insert into mytable values (:id, :val)" \
--parameter-sets "[[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueOne\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 2}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueTwo\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 3}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueThree\"}}]]"
```
Für Windows:
```
aws rds-data batch-execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "insert into mytable values (:id, :val)" ^
--parameter-sets "[[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueOne\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 2}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueTwo\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 3}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueThree\"}}]]"
```
**Anmerkung**
Verwenden Sie in der Option `--parameter-sets` keine Zeilenumbrüche.
## Übergeben einer SQL-Transaktion
Mit dem CLI-Befehl `aws rds-data commit-transaction` können Sie eine SQL-Transaktion beenden, die mit `aws rds-data begin-transaction` gestartet wurde, und die Änderungen übergeben.
Geben Sie zusätzlich zu den allgemeinen Optionen die folgende Option an:
+ `--transaction-id` (erforderlich) – die ID einer Transaktion, die über den CLI-Befehl `begin-transaction` gestartet wurde. Geben Sie die Transaktions-ID der Transaktion an, die Sie beenden und übergeben möchten.
Der folgende CLI-Befehl beendet beispielsweise eine SQL-Transaktion und übergibt die Änderungen.
Für Linux, macOS oder Unix:
```
aws rds-data commit-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--transaction-id "ABC1234567890xyz"
```
Für Windows:
```
aws rds-data commit-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--transaction-id "ABC1234567890xyz"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"transactionStatus": "Transaction Committed"
}
```
## Rollback einer SQL-Transaktion
Mit dem CLI-Befehl `aws rds-data rollback-transaction` können Sie einen Rollback für eine SQL-Transaktion ausführen, die mit `aws rds-data begin-transaction` gestartet wurde. Durch das Rollback einer Transaktion werden für sie ausgeführte Änderungen rückgängig gemacht.
**Wichtig**
Wenn die Transaktions-ID abgelaufen ist, wurde automatisch ein Rollback für die Transaktion ausgeführt. In diesem Fall gibt ein `aws rds-data rollback-transaction`-Befehl, der die abgelaufene Transaktions-ID angibt, einen Fehler zurück.
Geben Sie zusätzlich zu den allgemeinen Optionen die folgende Option an:
+ `--transaction-id` (erforderlich) – die ID einer Transaktion, die über den CLI-Befehl `begin-transaction` gestartet wurde. Geben Sie die Transaktions-ID der Transaktion an, für die Sie ein Rollback ausführen möchten.
Der folgende AWS CLI-Befehl führt beispielsweise einen Rollback für eine SQL-Transaktion aus.
Für Linux, macOS oder Unix:
```
aws rds-data rollback-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--transaction-id "ABC1234567890xyz"
```
Für Windows:
```
aws rds-data rollback-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--transaction-id "ABC1234567890xyz"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"transactionStatus": "Rollback Complete"
}
```
# Aufrufen der Daten-API von Amazon RDS aus einer Python-Anwendung
Sie können die Daten-API von Amazon RDS (Daten-API) aus einer Python-Anwendung aufrufen.
Die folgenden Beispiele verwenden das AWS SDK for Python (Boto). Weitere Informationen zu Boto finden Sie in der [AWS SDK for Python (Boto 3)-Dokumentation](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html).
Ersetzen Sie in jedem Beispiel den Amazon-Ressourcennamen (ARN) des DB-Clusters durch den ARN Ihres Aurora-DB-Clusters. Ersetzen Sie außerdem den geheimen ARN durch den ARN des geheimen Schlüssels in Secrets Manager, der den Zugriff auf den DB-Cluster ermöglicht.
**Topics**
+ [
## Ausführen einer SQL-Abfrage
](#data-api.calling.python.run-query)
+ [
## Ausführen einer DML SQL-Anweisung
](#data-api.calling.python.run-inert)
+ [
## Ausführen einer SQL-Transaktion
](#data-api.calling.python.run-transaction)
## Ausführen einer SQL-Abfrage
Sie können eine `SELECT`-Anweisung ausführen und die Ergebnisse mit einer Python-Anwendung abrufen.
Im folgenden Beispiel wird eine SQL-Abfrage ausgeführt.
```
import boto3
rdsData = boto3.client('rds-data')
cluster_arn = 'arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster'
secret_arn = 'arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret'
response1 = rdsData.execute_statement(
resourceArn = cluster_arn,
secretArn = secret_arn,
database = 'mydb',
sql = 'select * from employees limit 3')
print (response1['records'])
[
[
{
'longValue': 1
},
{
'stringValue': 'ROSALEZ'
},
{
'stringValue': 'ALEJANDRO'
},
{
'stringValue': '2016-02-15 04:34:33.0'
}
],
[
{
'longValue': 1
},
{
'stringValue': 'DOE'
},
{
'stringValue': 'JANE'
},
{
'stringValue': '2014-05-09 04:34:33.0'
}
],
[
{
'longValue': 1
},
{
'stringValue': 'STILES'
},
{
'stringValue': 'JOHN'
},
{
'stringValue': '2017-09-20 04:34:33.0'
}
]
]
```
## Ausführen einer DML SQL-Anweisung
Sie können eine Data Manipulation Language (DML)-Anweisung ausführen, um in Ihrer Datenbank Daten einzufügen, zu aktualisieren oder zu löschen. Sie können in DML-Anweisungen auch Parameter verwenden.
**Wichtig**
Wenn ein Aufruf kein Teil einer Transaktion ist, da er den Parameter `transactionID` nicht enthält, werden Änderungen, die sich aus dem Aufruf ergeben, automatisch übergeben.
Im folgenden Beispiel werden eine SQL Insert-Anweisung ausgeführt und Parameter verwendet.
```
import boto3
cluster_arn = 'arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster'
secret_arn = 'arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret'
rdsData = boto3.client('rds-data')
param1 = {'name':'firstname', 'value':{'stringValue': 'JACKSON'}}
param2 = {'name':'lastname', 'value':{'stringValue': 'MATEO'}}
paramSet = [param1, param2]
response2 = rdsData.execute_statement(resourceArn=cluster_arn,
secretArn=secret_arn,
database='mydb',
sql='insert into employees(first_name, last_name) VALUES(:firstname, :lastname)',
parameters = paramSet)
print (response2["numberOfRecordsUpdated"])
```
## Ausführen einer SQL-Transaktion
Sie können eine SQL-Transaktion starten, eine oder mehrere SQL-Anweisungen ausführen und anschließend die Änderungen mit einer Python-Anwendung übergeben.
**Wichtig**
Bei einer Transaktion kommt es zu einer Zeitüberschreitung, wenn es innerhalb von drei Minuten keine Aufrufe gibt, die ihre Transaktions-ID verwenden. Wenn es zu einer Zeitüberschreitung kommt, bevor die Transaktion festgeschrieben wird, wird die Transaktion automatisch zurückgesetzt.
Wenn Sie keine Transaktions-ID angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Im folgenden Beispiel wird eine SQL-Transaktion ausgeführt, die eine Zeile in eine Tabelle einfügt.
```
import boto3
rdsData = boto3.client('rds-data')
cluster_arn = 'arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster'
secret_arn = 'arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret'
tr = rdsData.begin_transaction(
resourceArn = cluster_arn,
secretArn = secret_arn,
database = 'mydb')
response3 = rdsData.execute_statement(
resourceArn = cluster_arn,
secretArn = secret_arn,
database = 'mydb',
sql = 'insert into employees(first_name, last_name) values('XIULAN', 'WANG')',
transactionId = tr['transactionId'])
cr = rdsData.commit_transaction(
resourceArn = cluster_arn,
secretArn = secret_arn,
transactionId = tr['transactionId'])
cr['transactionStatus']
'Transaction Committed'
response3['numberOfRecordsUpdated']
1
```
**Anmerkung**
Wenn Sie eine DDL-Anweisung ausführen, sollten Sie die Anweisung auch nach Ablauf des Aufrufs weiter ausführen. Wenn eine DDL-Anweisung vor Ende der Ausführung beendet wird, kann dies zu Fehlern und möglicherweise beschädigten Datenstrukturen führen. Um eine Anweisung weiter auszuführen, nachdem ein Aufruf das für die RDS-Daten-API geltende Zeitintervall von 45 Sekunden überschritten hat, legen Sie den Parameter `continueAfterTimeout` auf `true` fest.
# Aufrufen der Daten-API von Amazon RDS aus einer Java-Anwendung
Sie können die Daten-API von Amazon RDS (Daten-API) aus einer Java-Anwendung aufrufen.
Die folgenden Beispiele verwenden das AWS SDK for Java. Weitere Informationen finden Sie im [AWS SDK für Java-Entwicklerhandbuch](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/welcome.html).
Ersetzen Sie in jedem Beispiel den Amazon-Ressourcennamen (ARN) des DB-Clusters durch den ARN Ihres Aurora-DB-Clusters. Ersetzen Sie außerdem den geheimen ARN durch den ARN des geheimen Schlüssels in Secrets Manager, der den Zugriff auf den DB-Cluster ermöglicht.
**Topics**
+ [
## Ausführen einer SQL-Abfrage
](#data-api.calling.java.run-query)
+ [
## Ausführen einer SQL-Transaktion
](#data-api.calling.java.run-transaction)
+ [
## Ausführen einer Stapel-SQL-Operation
](#data-api.calling.java.run-batch)
## Ausführen einer SQL-Abfrage
Sie können eine `SELECT`-Anweisung ausführen und die Ergebnisse mit einer Java-Anwendung abrufen.
Im folgenden Beispiel wird eine SQL-Abfrage ausgeführt.
```
package com.amazonaws.rdsdata.examples;
import com.amazonaws.services.rdsdata.AWSRDSData;
import com.amazonaws.services.rdsdata.AWSRDSDataClient;
import com.amazonaws.services.rdsdata.model.ExecuteStatementRequest;
import com.amazonaws.services.rdsdata.model.ExecuteStatementResult;
import com.amazonaws.services.rdsdata.model.Field;
import java.util.List;
public class FetchResultsExample {
public static final String RESOURCE_ARN = "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster";
public static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret";
public static void main(String[] args) {
AWSRDSData rdsData = AWSRDSDataClient.builder().build();
ExecuteStatementRequest request = new ExecuteStatementRequest()
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withDatabase("mydb")
.withSql("select * from mytable");
ExecuteStatementResult result = rdsData.executeStatement(request);
for (List fields: result.getRecords()) {
String stringValue = fields.get(0).getStringValue();
long numberValue = fields.get(1).getLongValue();
System.out.println(String.format("Fetched row: string = %s, number = %d", stringValue, numberValue));
}
}
}
```
## Ausführen einer SQL-Transaktion
Sie können eine SQL-Transaktion starten, eine oder mehrere SQL-Anweisungen ausführen und anschließend die Änderungen mit einer Java-Anwendung übergeben.
**Wichtig**
Bei einer Transaktion kommt es zu einer Zeitüberschreitung, wenn es innerhalb von drei Minuten keine Aufrufe gibt, die ihre Transaktions-ID verwenden. Wenn es zu einer Zeitüberschreitung kommt, bevor die Transaktion festgeschrieben wird, wird die Transaktion automatisch zurückgesetzt.
Wenn Sie keine Transaktions-ID angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Im folgenden Beispiel wird eine SQL-Transaktion ausgeführt.
```
package com.amazonaws.rdsdata.examples;
import com.amazonaws.services.rdsdata.AWSRDSData;
import com.amazonaws.services.rdsdata.AWSRDSDataClient;
import com.amazonaws.services.rdsdata.model.BeginTransactionRequest;
import com.amazonaws.services.rdsdata.model.BeginTransactionResult;
import com.amazonaws.services.rdsdata.model.CommitTransactionRequest;
import com.amazonaws.services.rdsdata.model.ExecuteStatementRequest;
public class TransactionExample {
public static final String RESOURCE_ARN = "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster";
public static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret";
public static void main(String[] args) {
AWSRDSData rdsData = AWSRDSDataClient.builder().build();
BeginTransactionRequest beginTransactionRequest = new BeginTransactionRequest()
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withDatabase("mydb");
BeginTransactionResult beginTransactionResult = rdsData.beginTransaction(beginTransactionRequest);
String transactionId = beginTransactionResult.getTransactionId();
ExecuteStatementRequest executeStatementRequest = new ExecuteStatementRequest()
.withTransactionId(transactionId)
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withSql("INSERT INTO test_table VALUES ('hello world!')");
rdsData.executeStatement(executeStatementRequest);
CommitTransactionRequest commitTransactionRequest = new CommitTransactionRequest()
.withTransactionId(transactionId)
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN);
rdsData.commitTransaction(commitTransactionRequest);
}
}
```
**Anmerkung**
Wenn Sie eine DDL-Anweisung ausführen, sollten Sie die Anweisung auch nach Ablauf des Aufrufs weiter ausführen. Wenn eine DDL-Anweisung vor Ende der Ausführung beendet wird, kann dies zu Fehlern und möglicherweise beschädigten Datenstrukturen führen. Um eine Anweisung weiter auszuführen, nachdem ein Aufruf das für die RDS-Daten-API geltende Zeitintervall von 45 Sekunden überschritten hat, legen Sie den Parameter `continueAfterTimeout` auf `true` fest.
## Ausführen einer Stapel-SQL-Operation
Sie können mit einer Java-Anwendung Operationen für Masseneinfügungen und -aktualisierungen für ein Daten-Array ausführen. Sie können eine DML-Anweisung mit einem Array von Parametersätzen ausführen.
**Wichtig**
Wenn Sie keine Transaktions-ID angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Im folgenden Beispiel wird eine Batch-Einfügungs-Operation ausgeführt.
```
package com.amazonaws.rdsdata.examples;
import com.amazonaws.services.rdsdata.AWSRDSData;
import com.amazonaws.services.rdsdata.AWSRDSDataClient;
import com.amazonaws.services.rdsdata.model.BatchExecuteStatementRequest;
import com.amazonaws.services.rdsdata.model.Field;
import com.amazonaws.services.rdsdata.model.SqlParameter;
import java.util.Arrays;
public class BatchExecuteExample {
public static final String RESOURCE_ARN = "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster";
public static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret";
public static void main(String[] args) {
AWSRDSData rdsData = AWSRDSDataClient.builder().build();
BatchExecuteStatementRequest request = new BatchExecuteStatementRequest()
.withDatabase("test")
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withSql("INSERT INTO test_table2 VALUES (:string, :number)")
.withParameterSets(Arrays.asList(
Arrays.asList(
new SqlParameter().withName("string").withValue(new Field().withStringValue("Hello")),
new SqlParameter().withName("number").withValue(new Field().withLongValue(1L))
),
Arrays.asList(
new SqlParameter().withName("string").withValue(new Field().withStringValue("World")),
new SqlParameter().withName("number").withValue(new Field().withLongValue(2L))
)
));
rdsData.batchExecuteStatement(request);
}
}
```
# Steuern des Timeout-Verhaltens der Daten-API
Alle Aufrufe der Daten-API erfolgen synchron. Angenommen, Sie führen eine Daten-API-Operation durch, die eine SQL-Anweisung wie `INSERT` oder `CREATE TABLE` ausführt. Wenn der Daten-API-Aufruf erfolgreich Ergebnisse zurückgibt, ist die SQL-Verarbeitung abgeschlossen.
Standardmäßig bricht die Daten-API eine Operation ab und gibt einen Timeout-Fehler zurück, wenn sie nicht innerhalb von 45 Sekunden abgeschlossen wird. In diesem Fall werden die Daten nicht eingefügt, die Tabelle wird nicht erstellt usw.
Sie können die Daten-API verwenden, um lang andauernde Operationen auszuführen, die nicht innerhalb von 45 Sekunden abgeschlossen werden können. Wenn Sie davon ausgehen, dass ein Vorgang, z. B. eine Massen-`INSERT`- oder DDL-Operation an einer großen Tabelle, länger als 45 Sekunden dauert, können Sie für die Operation `ExecuteStatement` den Parameter `continueAfterTimeout` angeben. Ihre Anwendung erhält weiterhin den Timeout-Fehler. Die Operation wird jedoch weiter ausgeführt und nicht abgebrochen. Ein Beispiel finden Sie unter [Ausführen einer SQL-Transaktion](data-api.calling.java.md#data-api.calling.java.run-transaction).
Wenn das AWS SDK für Ihre Programmiersprache über einen eigenen Timeout-Zeitraum für API-Aufrufe oder HTTP-Socket-Verbindungen verfügt, stellen Sie sicher, dass alle diese Timeout-Zeiträume mehr als 45 Sekunden betragen. Bei einigen SDKs beträgt der Timeout-Zeitraum standardmäßig weniger als 45 Sekunden. Wir empfehlen, alle SDK-spezifischen oder Client-spezifischen Timeout-Zeiträume auf mindestens eine Minute festzulegen. Dadurch wird die Möglichkeit vermieden, dass Ihre Anwendung einen Timeout-Fehler erhält, während der Daten-API-Vorgang noch erfolgreich abgeschlossen wird. Auf diese Weise können Sie sicher sein, ob Sie den Vorgang wiederholen sollten oder nicht.
Nehmen wir beispielsweise an, dass das SDK einen Timeout-Fehler an Ihre Anwendung zurückgibt, die Daten-API-Operation aber trotzdem innerhalb des Daten-API-Timeout-Intervalls abgeschlossen wird. In diesem Fall könnte ein erneuter Ausführungsversuch der Operation Datenduplikate verursachen oder auf andere Weise zu falschen Ergebnissen führen. Das SDK wiederholt die Operation möglicherweise automatisch, wodurch falsche Daten entstehen, ohne dass Ihre Anwendung etwas unternommen hat.
Das Timeout-Intervall ist besonders wichtig für das Java-2-SDK. In diesem SDK betragen das API-Aufruf-Timeout und das HTTP-Socket-Timeout standardmäßig beide 30 Sekunden. In diesem Beispiel wird für das Timeout ein höherer Wert festgelegt:
```
public RdsDataClient createRdsDataClient() {
return RdsDataClient.builder()
.region(Region.US_EAST_1) // Change this to your desired Region
.overrideConfiguration(createOverrideConfiguration())
.httpClientBuilder(createHttpClientBuilder())
.credentialsProvider(defaultCredentialsProvider()) // Change this to your desired credentials provider
.build();
}
private static ClientOverrideConfiguration createOverrideConfiguration() {
return ClientOverrideConfiguration.builder()
.apiCallTimeout(Duration.ofSeconds(60))
.build();
}
private HttpClientBuilder createHttpClientBuilder() {
return ApacheHttpClient.builder() // Change this to your desired HttpClient
.socketTimeout(Duration.ofSeconds(60));
}
```
In diesem äquivalenten Beispiel wird der asynchrone Daten-Client verwendet:
```
public static RdsDataAsyncClient createRdsDataAsyncClient() {
return RdsDataAsyncClient.builder()
.region(Region.US_EAST_1) // Change this to your desired Region
.overrideConfiguration(createOverrideConfiguration())
.credentialsProvider(defaultCredentialsProvider()) // Change this to your desired credentials provider
.build();
}
private static ClientOverrideConfiguration createOverrideConfiguration() {
return ClientOverrideConfiguration.builder()
.apiCallAttemptTimeout(Duration.ofSeconds(60))
.build();
}
private HttpClientBuilder createHttpClientBuilder() {
return NettyNioAsyncHttpClient.builder() // Change this to your desired AsyncHttpClient
.readTimeout(Duration.ofSeconds(60));
}
```
# Verwenden der Java-Client-Bibliothek für die RDS-Daten-API
Sie können eine Java-Client-Bibliothek für die RDS-Daten-API (Daten-API) herunterladen und verwenden. Die Java-Client-Bibliothek stellt eine Alternative zur Verwendung der Daten-API dar. Mit dieser Bibliothek können Sie Ihre clientseitigen Klassen den Anfragen und Antworten der Daten-API zuordnen. Dieser Mapping-Support kann die Integration mit einigen bestimmten Java-Typen wie etwa `Date`, `Time` und `BigDecimal` erleichtern.
## Herunterladen der Java Client-Bibliothek für die Daten-API
Die Data API Java-Clientbibliothek ist GitHub am folgenden Speicherort als Open Source verfügbar:
[ https://github.com/awslabs/rds-data-api-client-library-java](https://github.com/awslabs/rds-data-api-client-library-java)
Sie können die Bibliothek manuell aus den Quelldateien aufbauen, die bewährte Methode ist jedoch, die Bibliothek unter Verwendung der Apache Maven-Dependenzverwaltung zu nutzen. Fügen Sie die folgende Abhängigkeit zu Ihrer Maven-POM-Datei hinzu.
Verwenden Sie für Version 2.x, die mit AWS SDK 2.x kompatibel ist, Folgendes:
```
software.amazon.rdsdata
rds-data-api-client-library-java
2.0.0
```
Verwenden Sie für Version 1.x, die mit AWS SDK 1.x kompatibel ist, Folgendes:
```
software.amazon.rdsdata
rds-data-api-client-library-java
1.0.8
```
## Java Client-Bibliothek-Beispiele
Nachfolgend finden Sie einige typische Beispiele für die Verwendung der Daten-API-Java-Client-Bibliothek. Diese Beispiele gehen davon aus, dass Sie eine Tabelle `accounts` mit zwei Spalten haben: `accountId` und `name`. Weiterhin haben Sie das folgende Datentransferobjekt (DTO):
```
public class Account {
int accountId;
String name;
// getters and setters omitted
}
```
In der Client-Bibliothek können Sie Parameter DTOs als Eingabeparameter übergeben. Das folgende Beispiel zeigt, wie Kunden Eingabeparametersätzen zugeordnet DTOs werden.
```
var account1 = new Account(1, "John");
var account2 = new Account(2, "Mary");
client.forSql("INSERT INTO accounts(accountId, name) VALUES(:accountId, :name)")
.withParamSets(account1, account2)
.execute();
```
In manchen Fällen ist es einfacher, mit einfachen Werten als Eingabeparametern zu arbeiten. Verwenden Sie dazu die folgende Syntax.
```
client.forSql("INSERT INTO accounts(accountId, name) VALUES(:accountId, :name)")
.withParameter("accountId", 3)
.withParameter("name", "Zhang")
.execute();
```
Es folgt ein weiteres Beispiel, das mit einfachen Werten als Eingabeparametern arbeitet.
```
client.forSql("INSERT INTO accounts(accountId, name) VALUES(?, ?)", 4, "Carlos")
.execute();
```
Die Client-Bibliothek ermöglicht eine automatische Zuordnung, DTOs wann ein Ergebnis zurückgegeben wird. Die folgenden Beispiele zeigen, wie das Ergebnis Ihrem DTOs zugeordnet wird.
```
List result = client.forSql("SELECT * FROM accounts")
.execute()
.mapToList(Account.class);
Account result = client.forSql("SELECT * FROM accounts WHERE account_id = 1")
.execute()
.mapToSingle(Account.class);
```
In vielen Fällen enthält die Datenbank-Ergebnismenge einen einzigen Wert. Um das Abrufen solcher Ergebnisse zu vereinfachen, bietet die Kundenbibliothek die folgende API an:
```
int numberOfAccounts = client.forSql("SELECT COUNT(*) FROM accounts")
.execute()
.singleValue(Integer.class);
```
**Anmerkung**
Die `mapToList`-Funktion konvertiert einen SQL-Ergebnissatz in eine benutzerdefinierte Objektliste. Wir unterstützen die Verwendung der `.withFormatRecordsAs(RecordsFormatType.JSON)`-Anweisung in einem `ExecuteStatement`-Anruf für die Java-Clientbibliothek nicht, weil sie dem gleichen Zweck dient. Weitere Informationen finden Sie unter [Verarbeiten von Abfrageergebnissen der Amazon-RDS-Data-API im JSON-Format](data-api-json.md).
# Verarbeiten von Abfrageergebnissen der Amazon-RDS-Data-API im JSON-Format
Wenn Sie die `ExecuteStatement`-Operation aufrufen, können Sie auswählen, ob die Abfrageergebnisse als Zeichenfolge im JSON-Format zurückgegeben werden sollen. Auf diese Weise können Sie die JSON-Parsing-Funktionen Ihrer Programmiersprache verwenden, um die Ergebnismenge zu interpretieren und neu zu formatieren. Dies kann dazu beitragen, zu vermeiden, zusätzlichen Code zu schreiben, um die Ergebnismenge zu durchlaufen und jeden Spaltenwert zu interpretieren.
Zum Anfordern der Ergebnismenge im JSON-Format übergeben Sie den optionalen `formatRecordsAs`-Parameter mit dem Wert `JSON`. Die JSON-formatierte Ergebnismenge wird im Feld `formattedRecords` der `ExecuteStatementResponse`-Struktur zurückgegeben.
Die `BatchExecuteStatement`-Aktion gibt keine Ergebnismenge zurück. Daher gilt die JSON-Option nicht für diese Aktion.
Wenn Sie die Schlüssel in der JSON-Hash-Struktur anpassen möchten, definieren Sie Spaltenaliasnamen in der Ergebnismenge. Verwenden Sie dazu die `AS`-Klausel in der Spaltenliste Ihrer SQL-Abfrage.
Sie können die JSON-Funktion verwenden, um die Ergebnismenge besser lesbar zu machen und den Inhalt sprachspezifischen Frameworks zuzuordnen. Da das Volume der ASCII-kodierten Ergebnismenge größer als die Standarddarstellung ist, können Sie die Standarddarstellung für Abfragen auswählen, die eine große Anzahl von Zeilen oder große Spaltenwerte zurückgeben, die mehr Speicher belegen, als für Ihre Anwendung verfügbar ist.
**Topics**
+ [
## Abrufen von Abfrageergebnissen im JSON-Format
](#data-api-json-querying)
+ [
## Datentypenzuordnung
](#data-api-json-datatypes)
+ [
## Fehlerbehebung
](#data-api-json-troubleshooting)
+ [
## Beispiele
](#data-api-json-examples)
## Abrufen von Abfrageergebnissen im JSON-Format
Damit Sie die Ergebnismenge als JSON-Zeichenfolge erhalten, schließen Sie `.withFormatRecordsAs(RecordsFormatType.JSON)` in den `ExecuteStatement`-Aufruf ein. Der Rückgabewert wird im Feld `formattedRecords` als JSON-Zeichenfolge angezeigt. In diesem Fall hat `columnMetadata` den Wert `null`. Die Spaltenbeschriftungen sind die Schlüssel des Objekts, das jede Zeile darstellt. Diese Spaltennamen werden für jede Zeile in der Ergebnismenge wiederholt. Die Spaltenwerte sind in Anführungszeichen gesetzte Zeichenfolgen, numerische Werte oder Sonderwerte, die `true`, `false` oder `null` darstellen. Spaltenmetadaten wie Längenbeschränkungen und der genaue Typ für Zahlen und Zeichenfolgen werden in der JSON-Antwort nicht beibehalten.
Wenn Sie den `.withFormatRecordsAs()`-Aufruf weglassen oder einen Parameter `NONE` angeben, wird die Ergebnismenge im Binärformat unter Verwendung der Felder `Records` und `columnMetadata` zurückgegeben.
## Datentypenzuordnung
Die SQL-Werte in der Ergebnismenge werden einem kleineren Satz von JSON-Typen zugeordnet. Die Werte werden in JSON als Zeichenfolgen, Zahlen und einige spezielle Konstanten wie `true`, `false` und `null` dargestellt. Sie können diese Werte in Variablen in Ihrer Anwendung umwandeln, indem Sie eine starke oder schwache Eingabe verwenden, die für Ihre Programmiersprache geeignet ist.
****
| JDBC-Datentyp | JSON-Datentyp |
| --- | --- |
| `INTEGER`, `TINYINT`, `SMALLINT`, `BIGINT` | Die Standardeinstellung ist Zahl. Zeichenfolge, wenn die Option `LongReturnType` auf `STRING` eingestellt ist. |
| `FLOAT`, `REAL`, `DOUBLE` | Anzahl |
| `DECIMAL` | Die Standardeinstellung ist Zeichenfolge. Zahl, wenn die Option `DecimalReturnType` auf `DOUBLE_OR_LONG` eingestellt ist. |
| `STRING` | String |
| `BOOLEAN`, `BIT` | Boolesch |
| `BLOB`, `BINARY`, `VARBINARY`, `LONGVARBINARY` | Zeichenfolge in Base64-Kodierung. |
| `CLOB` | String |
| `ARRAY` | Array |
| `NULL` | `null` |
| Andere Typen (einschließlich datums- und zeitbezogener Typen) | String |
## Fehlerbehebung
Die JSON-Antwort ist auf 10 Megabyte begrenzt. Wenn die Antwort größer als dieses Limit ist, erhält Ihr Programm einen `BadRequestException`-Fehler. In diesem Fall können Sie den Fehler mit einer der folgenden Methoden beheben:
+ Reduzieren Sie die Anzahl der Zeilen in der Ergebnismenge. Fügen Sie dazu eine `LIMIT`-Klausel hinzu. Sie können eine große Ergebnismenge in mehrere kleinere aufteilen, indem Sie mehrere Abfragen mit den Klauseln `LIMIT` und `OFFSET` senden.
Wenn die Ergebnismenge Zeilen enthält, die durch die Anwendungslogik herausgefiltert werden, können Sie diese Zeilen aus der Ergebnismenge entfernen, indem Sie der `WHERE`-Klausel weitere Bedingungen hinzufügen.
+ Reduzieren Sie die Anzahl der Spalten in der Ergebnismenge. Entfernen Sie dazu Elemente aus der Auswahlliste der Abfrage.
+ Verkürzen Sie die Spaltenbeschriftungen, indem Sie Spaltenaliasnamen in der Abfrage verwenden. Jeder Spaltenname wird in der JSON-Zeichenfolge für jede Zeile der Ergebnismenge wiederholt. Daher könnte ein Abfrageergebnis mit langen Spaltennamen und vielen Zeilen die Größenbeschränkung überschreiten. Verwenden Sie insbesondere Spaltenaliasnamen für komplizierte Ausdrücke, um zu vermeiden, dass der gesamte Ausdruck in der JSON-Zeichenfolge wiederholt wird.
+ Während Sie mit SQL Spaltenaliasnamen verwenden können, um eine Ergebnismenge mit mehr als einer Spalte mit demselben Namen zu erzeugen, sind doppelte Schlüsselnamen in JSON nicht zulässig. Die RDS-Daten-API gibt einen Fehler zurück, wenn Sie die Ergebnismenge im JSON-Format anfordern und mehr als eine Spalte denselben Namen hat. Stellen Sie daher sicher, dass alle Spaltenbeschriftungen eindeutige Namen haben.
## Beispiele
Die folgenden Java-Beispiele zeigen, wie Sie `ExecuteStatement` mit der Antwort als JSON-formatierte Zeichenfolge aufrufen und dann die Ergebnismenge interpretieren. Ersetzen Sie die entsprechenden Werte für die Parameter *databaseName*, *secretStoreArn* und *clusterArn*.
Das folgende Java-Beispiel veranschaulicht eine Abfrage, die einen numerischen Dezimalwert in der Ergebnismenge zurückgibt. `assertThat`-Aufrufe testen anhand der Regeln für JSON-Ergebnismengen, ob die Felder der Antwort die erwarteten Eigenschaften haben.
Dieses Beispiel funktioniert mit dem folgenden Schema und den folgenden Beispieldaten:
```
create table test_simplified_json (a float);
insert into test_simplified_json values(10.0);
```
```
public void JSON_result_set_demo() {
var sql = "select * from test_simplified_json";
var request = new ExecuteStatementRequest()
.withDatabase(databaseName)
.withSecretArn(secretStoreArn)
.withResourceArn(clusterArn)
.withSql(sql)
.withFormatRecordsAs(RecordsFormatType.JSON);
var result = rdsdataClient.executeStatement(request);
}
```
Der Wert des Felds `formattedRecords` aus dem vorhergehenden Programm lautet:
```
[{"a":10.0}]
```
Die Felder `Records` und `ColumnMetadata` in der Antwort sind aufgrund des Vorhandenseins der JSON-Ergebnismenge beide null.
Das folgende Java-Beispiel veranschaulicht eine Abfrage, die einen numerischen Ganzzahlwert in der Ergebnismenge zurückgibt. Das Beispiel ruft `getFormattedRecords` auf, um nur die JSON-formatierte Zeichenfolge zurückzugeben und die anderen Antwortfelder zu ignorieren, die leer oder null sind. Im Beispiel wird das Ergebnis in eine Struktur deserialisiert, die eine Liste von Datensätzen darstellt. Jeder Datensatz enthält Felder, deren Namen den Spaltenaliasnamen aus der Ergebnismenge entsprechen. Diese Methode vereinfacht den Code, der die Ergebnismenge analysiert. Ihre Anwendung muss nicht die Zeilen und Spalten der Ergebnismenge durchlaufen und jeden Wert in den entsprechenden Typ konvertieren.
Dieses Beispiel funktioniert mit dem folgenden Schema und den folgenden Beispieldaten:
```
create table test_simplified_json (a int);
insert into test_simplified_json values(17);
```
```
public void JSON_deserialization_demo() {
var sql = "select * from test_simplified_json";
var request = new ExecuteStatementRequest()
.withDatabase(databaseName)
.withSecretArn(secretStoreArn)
.withResourceArn(clusterArn)
.withSql(sql)
.withFormatRecordsAs(RecordsFormatType.JSON);
var result = rdsdataClient.executeStatement(request)
.getFormattedRecords();
/* Turn the result set into a Java object, a list of records.
Each record has a field 'a' corresponding to the column
labelled 'a' in the result set. */
private static class Record { public int a; }
var recordsList = new ObjectMapper().readValue(
response, new TypeReference>() {
});
}
```
Der Wert des Felds `formattedRecords` aus dem vorhergehenden Programm lautet:
```
[{"a":17}]
```
Zum Abrufen der Spalte `a` der Ergebniszeile 0 würde sich die Anwendung auf `recordsList.get(0).a` beziehen.
Im Gegensatz dazu zeigt das folgende Java-Beispiel die Art von Code, der zum Erstellen einer Datenstruktur erforderlich ist, die die Ergebnismenge enthält, wenn Sie das JSON-Format nicht verwenden. In diesem Fall enthält jede Zeile der Ergebnismenge Felder mit Informationen über einen einzelnen Benutzer. Das Erstellen einer Datenstruktur zur Darstellung der Ergebnismenge erfordert das Durchlaufen der Zeilen. Für jede Zeile ruft der Code den Wert jedes Felds ab, führt eine entsprechende Typkonvertierung durch und weist das Ergebnis dem entsprechenden Feld im Objekt zu, das die Zeile darstellt. Dann fügt der Code das Objekt, das jeden Benutzer repräsentiert, der Datenstruktur hinzu, die die gesamte Ergebnismenge darstellt. Wenn die Abfrage geändert wurde, um Felder in der Ergebnismenge neu anzuordnen, hinzuzufügen oder zu entfernen, müsste sich der Anwendungscode ebenfalls ändern.
```
/* Verbose result-parsing code that doesn't use the JSON result set format */
for (var row: response.getRecords()) {
var user = User.builder()
.userId(row.get(0).getLongValue())
.firstName(row.get(1).getStringValue())
.lastName(row.get(2).getStringValue())
.dob(Instant.parse(row.get(3).getStringValue()))
.build();
result.add(user);
}
```
Die folgenden Beispielwerte zeigen die Werte des Felds `formattedRecords` für Ergebnismengen mit unterschiedlicher Anzahl von Spalten, Spaltenaliasnamen und Spaltendatentypen.
Wenn die Ergebnismenge mehrere Zeilen enthält, wird jede Zeile als Objekt dargestellt, das ein Array-Element ist. Jede Spalte in der Ergebnismenge wird zu einem Schlüssel im Objekt. Die Schlüssel werden für jede Zeile in der Ergebnismenge wiederholt. Daher müssen Sie für Ergebnismengen, die aus vielen Zeilen und Spalten bestehen, möglicherweise kurze Spaltenaliasnamen definieren, um zu vermeiden, dass das Längenlimit für die gesamte Antwort überschritten wird.
Dieses Beispiel funktioniert mit dem folgenden Schema und den folgenden Beispieldaten:
```
create table sample_names (id int, name varchar(128));
insert into sample_names values (0, "Jane"), (1, "Mohan"), (2, "Maria"), (3, "Bruce"), (4, "Jasmine");
```
```
[{"id":0,"name":"Jane"},{"id":1,"name":"Mohan"},
{"id":2,"name":"Maria"},{"id":3,"name":"Bruce"},{"id":4,"name":"Jasmine"}]
```
Wenn eine Spalte in der Ergebnismenge als Ausdruck definiert ist, wird der Text des Ausdrucks zum JSON-Schlüssel. Daher ist es normalerweise praktisch, einen beschreibenden Spaltenalias für jeden Ausdruck in der Auswahlliste der Abfrage zu definieren. Die folgende Abfrage enthält beispielsweise Ausdrücke wie Funktionsaufrufe und arithmetische Operationen in ihrer Auswahlliste.
```
select count(*), max(id), 4+7 from sample_names;
```
Diese Ausdrücke werden als Schlüssel an die JSON-Ergebnismenge übergeben.
```
[{"count(*)":5,"max(id)":4,"4+7":11}]
```
Wenn Sie `AS`-Spalten mit beschreibenden Beschriftungen hinzufügen, können die Schlüssel in der JSON-Ergebnismenge einfacher interpretiert werden.
```
select count(*) as rows, max(id) as largest_id, 4+7 as addition_result from sample_names;
```
Bei der überarbeiteten SQL-Abfrage werden die Spaltenbeschriftungen, die durch die `AS`-Klauseln definiert werden, als Schlüsselnamen verwendet.
```
[{"rows":5,"largest_id":4,"addition_result":11}]
```
Der Wert für jedes Schlüssel-Wert-Paar in der JSON-Zeichenfolge kann eine Zeichenfolge in Anführungszeichen sein. Die Zeichenfolge enthält möglicherweise Unicode-Zeichen. Wenn die Zeichenfolge Escape-Sequenzen oder die Zeichen `"` oder `\` enthält, wird diesen Zeichen ein Escape-Zeichen mit umgekehrtem Schrägstrich vorangestellt. Die folgenden Beispiele für JSON-Zeichenfolgen veranschaulichen diese Möglichkeiten. Das Ergebnis `string_with_escape_sequences` enthält z. B. die Sonderzeichen Rücktaste, Zeilenumbruch, Wagenrücklauf, Tabulator, Seitenvorschub und `\`.
```
[{"quoted_string":"hello"}]
[{"unicode_string":"邓不利多"}]
[{"string_with_escape_sequences":"\b \n \r \t \f \\ '"}]
```
Der Wert für jedes Schlüssel-Wert-Paar in der JSON-Zeichenfolge kann auch eine Zahl darstellen. Die Zahl kann eine Ganzzahl, ein Gleitkommawert, ein negativer Wert oder ein Wert sein, der in Exponentialschreibweise dargestellt wird. Die folgenden Beispiele für JSON-Zeichenfolgen veranschaulichen diese Möglichkeiten.
```
[{"integer_value":17}]
[{"float_value":10.0}]
[{"negative_value":-9223372036854775808,"positive_value":9223372036854775807}]
[{"very_small_floating_point_value":4.9E-324,"very_large_floating_point_value":1.7976931348623157E308}]
```
Boolesche und Nullwerte werden mit den Sonderschlüsselwörtern `true`, `false` und `null` ohne Anführungszeichen dargestellt. Die folgenden Beispiele für JSON-Zeichenfolgen veranschaulichen diese Möglichkeiten.
```
[{"boolean_value_1":true,"boolean_value_2":false}]
[{"unknown_value":null}]
```
Wenn Sie einen Wert eines BLOB-Typs auswählen, wird das Ergebnis in der JSON-Zeichenfolge als Base64-kodierter Wert dargestellt. Wenn Sie den Wert wieder in seine ursprüngliche Darstellung umwandeln möchten, können Sie die entsprechende Dekodierungsfunktion in der Sprache Ihrer Anwendung verwenden. In Java rufen Sie beispielsweise die Funktion `Base64.getDecoder().decode()` auf. Die folgende Beispielausgabe zeigt das Ergebnis der Auswahl des BLOB-Werts `hello world` und gibt die Ergebnismenge als JSON-Zeichenfolge zurück.
```
[{"blob_column":"aGVsbG8gd29ybGQ="}]
```
Das folgende Python-Beispiel zeigt, wie Sie auf die Werte aus dem Ergebnis eines Aufrufs der Python-Funktion `execute_statement` zugreifen. Die Ergebnismenge ist ein Zeichenfolgenwert im Feld `response['formattedRecords']`. Der Code verwandelt die JSON-Zeichenfolge durch Aufrufen der Funktion `json.loads` in eine Datenstruktur. Dann ist jede Zeile der Ergebnismenge ein Listenelement innerhalb der Datenstruktur und innerhalb jeder Zeile können Sie auf jedes Feld der Ergebnismenge nach Namen verweisen.
```
import json
result = json.loads(response['formattedRecords'])
print (result[0]["id"])
```
Das folgende JavaScript-Beispiel zeigt, wie Sie auf die Werte aus dem Ergebnis eines Aufrufs der JavaScript-Funktion `executeStatement` zugreifen. Die Ergebnismenge ist ein Zeichenfolgenwert im Feld `response.formattedRecords`. Der Code verwandelt die JSON-Zeichenfolge durch Aufrufen der Funktion `JSON.parse` in eine Datenstruktur. Dann ist jede Zeile der Ergebnismenge ein Array-Element innerhalb der Datenstruktur und innerhalb jeder Zeile können Sie auf jedes Feld der Ergebnismenge nach Namen verweisen.
```
```
# Fehlerbehebung bei Problemen mit der Amazon-RDS-Daten-API
Verwenden Sie die folgenden Abschnitte mit dem Titel „Allgemeine Fehlermeldungen“, um Probleme zu beheben, die Sie mit der Amazon-RDS-Daten-API (Daten-API) haben.
**Topics**
+ [
## Transaktion nicht gefunden
](#data-api.troubleshooting.tran-id-not-found)
+ [
## 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)
+ [
## HttpEndpoint ist nicht für Cluster aktiviert
](#data-api.troubleshooting.http-endpoint-not-enabled)
+ [
## DatabaseErrorException: Transaction führt immer noch eine Abfrage aus
](#data-api.troubleshooting.txn-concurrent-requests-rejected)
+ [
## Ausnahme aufgrund eines nicht unterstützten Ergebnisses
](#data-api.troubleshooting.unsupported-result)
+ [
## Keine Unterstützung für mehrere Anweisungen
](#data-api.troubleshooting.multi-statements)
+ [
## Keine Unterstützung für den Schemaparameter
](#data-api.troubleshooting.schema-parameter)
+ [
## IPv6 Probleme mit der Konnektivität
](#data-api.troubleshooting.ipv6-connectivity)
## Transaktion nicht gefunden
In diesem Fall wurde die in einem Data-API-Aufruf angegebene Transaktions-ID nicht gefunden. Die Ursache für dieses Problem wird an die Fehlermeldung angehängt und ist eine der folgenden:
+ Die Transaktion ist möglicherweise abgelaufen.
Stellen Sie sicher, dass jeder Transaktionsaufruf innerhalb von drei Minuten nach dem letzten ausgeführt wird.
Es ist auch möglich, dass die angegebene Transaktions-ID nicht durch einen [BeginTransaction](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BeginTransaction.html)Anruf erstellt wurde. Stellen Sie sicher, dass Ihr Aufruf eine gültige Transaktions-ID hat.
+ Ein vorheriger Aufruf führte zu einer Beendigung Ihrer Transaktion.
Die Transaktion wurde bereits von Ihrem `CommitTransaction`- oder `RollbackTransaction`-Aufruf beendet.
+ Die Transaktion wurde aufgrund eines Fehlers eines früheren Aufrufs abgebrochen.
Prüfen Sie, ob Ihre vorherigen Aufrufe Ausnahmen ausgelöst haben.
Informationen zum Ausführen von Transaktionen finden Sie unter [Aufrufen der Daten-API von Amazon RDS](data-api.calling.md).
## Packet for Query Is Too Large (Paket für Abfrage zu groß)
In diesem Fall war die zurückgegebene Ergebnismenge für eine Zeile 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)
In diesem Fall war die Größe der von der Datenbank zurückgegebenen Ergebnismenge zu groß. Das Data-API-Limit beträgt 1 MiB für die von der Datenbank zurückgegebene Ergebnismenge.
Um dieses Problem zu beheben, stellen Sie sicher, dass Aufrufe der Daten-API höchstens 1 MiB Daten zurückgeben. Wenn Sie mehr als 1 MiB zurückgeben müssen, können Sie mit der `LIMIT`-Klausel in Ihrer Abfrage mehrere [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html)-Aufrufe verwenden.
Weitere Informationen über die `LIMIT`-Klausel finden Sie unter [SELECT-Syntax](https://dev.mysql.com/doc/refman/8.0/en/select.html) in der MySQL-Dokumentation.
## HttpEndpoint ist nicht für Cluster aktiviert
Überprüfen Sie die folgenden möglichen Ursachen für dieses Problem:
+ Der Aurora-DB-Cluster unterstützt die Daten-API nicht. Informationen zu den Typen von DB-Clustern, die die RDS-Daten-API unterstützt, finden Sie unter [Verfügbarkeit von Regionen und Versionen für die Amazon-RDS-Daten-API](data-api.regions.md).
+ Die Daten-API ist für den Aurora-DB-Cluster nicht aktiviert. Um die Daten-API mit einem Aurora-DB-Cluster zu verwenden, muss die Daten-API für den DB-Cluster aktiviert sein. Informationen zur Aktivierung der Data-API finden Sie unter [Aktivieren der Amazon-RDS-Daten-API](data-api.enabling.md).
+ Der DB-Cluster wurde umbenannt, nachdem die Daten-API für ihn aktiviert wurde. Deaktivieren Sie in diesem Fall die Daten-API für diesen Cluster und aktivieren Sie sie dann erneut.
+ Der von Ihnen angegebene ARN stimmt nicht genau mit dem ARN des Clusters überein. Stellen Sie sicher, dass der von einer anderen Quelle zurückgegebene oder durch Programmlogik erstellte ARN genau mit dem ARN des Clusters übereinstimmt. Stellen Sie beispielsweise sicher, dass der von Ihnen verwendete ARN die richtigen Groß-/Kleinschreibung für alle alphabetischen Zeichen aufweist.
## DatabaseErrorException: Transaction führt immer noch eine Abfrage aus
Wenn Ihre Anwendung eine Anfrage mit einer Transaktions-ID sendet und diese Transaktion gerade eine weitere Anfrage verarbeitet, gibt die Daten-API sofort diesen Fehler an Ihre Anwendung zurück. Dieser Zustand kann auftreten, wenn Ihre Anwendung asynchrone Anfragen stellt und dabei einen Mechanismus wie „Promises“ in Javascript verwendet.
Um dieses Problem zu lösen, warten Sie, bis die vorherige Anfrage abgeschlossen ist, und versuchen Sie es dann erneut. Sie können den Schritt so lange wiederholen, bis der Fehler nicht mehr auftritt oder die Anwendung eine andere Art von Fehler erhält.
Dieser Zustand kann bei der Daten-API für Aurora Serverless v2- und für bereitgestellte Instances auftreten. In der Daten-API für Aurora Serverless v1 warten nachfolgende Anfragen für dieselbe Transaktions-ID automatisch, bis die vorherige Anfrage abgeschlossen ist. Bei diesem älteren Verhalten kann es jedoch möglicherweise zu Timeouts kommen, wenn die vorherige Anfrage zu lange gedauert. Wenn Sie eine ältere Daten-API-Anwendung portieren, die gleichzeitige Anfragen stellt, ändern Sie Ihre Logik für die Ausnahmeverarbeitung so, dass sie diese neue Art von Fehler berücksichtigt.
## Ausnahme aufgrund eines nicht unterstützten Ergebnisses
Die Daten-API unterstützt nicht alle Datentypen. Dieser Fehler tritt auf, wenn Sie eine Abfrage ausführen, die einen nicht unterstützten Datentyp zurückgibt.
Um dieses Problem zu umgehen, konvertieren Sie den nicht unterstützten Datentyp in `TEXT`. Beispiel:
```
SELECT custom_type::TEXT FROM my_table;
-- OR
SELECT CAST(custom_type AS TEXT) FROM my_table;
```
## Keine Unterstützung für mehrere Anweisungen
Mehrere Anweisungen werden in der Daten-API für Aurora Serverless v2 und bereitgestellte Cluster nicht unterstützt. Wenn Sie versuchen, mehrere Anweisungen in einem einzigen API-Aufruf auszuführen, wird der Fehler zurückgegeben.
Um mehrere Anweisungen auszuführen, nutzen Sie separate `ExecuteStatement`-API-Aufrufe oder die `BatchExecuteStatement`-API für die Stapelverarbeitung.
## Keine Unterstützung für den Schemaparameter
Aurora Serverless v1 ignoriert den Schemaparameter stillschweigend. Aurora Serverless v2 und bereitgestellte Cluster hingegen lehnen API-Aufrufe, die den Schemaparameter enthalten, explizit ab.
Um dieses Problem zu lösen, entfernen Sie den Schemaparameter aus allen Aufrufen der Daten-API, wenn Sie Aurora Serverless v2 oder bereitgestellte Cluster verwenden.
## IPv6 Probleme mit der Konnektivität
Wenn beim Herstellen einer Verbindung zur Daten-API über IPv6 Endpunkte Probleme auftreten, überprüfen Sie die folgenden möglichen Ursachen:
+ **Netzwerk unterstützt nicht IPv6**: Stellen Sie sicher, dass Ihre Netzwerkinfrastruktur dies unterstützt IPv6 und ob das IPv6 Routing korrekt konfiguriert ist.
+ **Probleme mit der DNS-Auflösung**: Stellen Sie sicher, dass Ihr DNS-Resolver AAAA-Datensätze für die Dual-Stack-Endpunkte auflösen kann (z. B. `rds-data.us-east-1.api.aws`).
+ **Sicherheitsgruppenkonfiguration**: Aktualisieren Sie die Sicherheitsgruppenregeln, um IPv6 Datenverkehr auf Port 443 (HTTPS) zuzulassen. Fügen Sie Regeln für IPv6 CIDR-Blöcke hinzu (z. B. `::/0` für alle IPv6 Adressen).
+ **Netzwerk-ACL-Konfiguration**: Stellen Sie sicher, dass das Netzwerk den IPv6 Datenverkehr an den erforderlichen Ports ACLs zulässt.
+ **Kompatibilität mit der Clientbibliothek**: Stellen Sie sicher, dass Ihre HTTP-Clientbibliotheken IPv6 und Dual-Stack-Konnektivität AWS SDKs unterstützen.
+ **VPC-Endpunktkonfiguration**: Stellen Sie bei Verwendung sicher PrivateLink, dass Ihr VPC-Endpunkt für die Unterstützung konfiguriert ist IPv6 und dass den zugehörigen Subnetzen IPv6 CIDR-Blöcke zugewiesen sind.
So beheben Sie Verbindungsprobleme: IPv6
1. Testen Sie die Konnektivität mit den Endpunkten „ IPv4-only“ (`.amazonaws.com`), um sicherzustellen, dass das Problem spezifisch für ist. IPv6
1. Verwenden Sie Netzwerkdiagnosetools, um die IPv6 Konnektivität zu den Dual-Stack-Endpunkten zu überprüfen.
1. Überprüfen Sie die CloudTrail Protokolle auf Authentifizierungs- oder Autorisierungsfehler bei der Verwendung von IPv6 Endpunkten.
1. Stellen Sie sicher, dass Ihre Anwendung korrekt für die Verwendung des neuen Dual-Stack-Endpunkts konfiguriert ist. URLs
# Protokollieren von Amazon RDS Data API-Aufrufen mit AWS CloudTrail
Die RDS-Daten-API (Daten-API) ist in einen Dienst integriert AWS CloudTrail, der eine Aufzeichnung der von einem Benutzer, einer Rolle oder einem AWS Dienst ausgeführten Aktionen in der Daten-API bereitstellt. CloudTrail erfasst alle API-Aufrufe für Data API als Ereignisse, einschließlich Aufrufe von der Amazon RDS-Konsole und von Codeaufrufen für Daten-API-Operationen. Wenn Sie einen Trail erstellen, können Sie die kontinuierliche Bereitstellung von CloudTrail Ereignissen an einen Amazon S3 S3-Bucket aktivieren, einschließlich Ereignissen für die Daten-API. Anhand der von CloudTrail gesammelten Daten können Sie eine Vielzahl von Informationen ermitteln. Diese Informationen umfassen die Anforderung an Data API, die IP-Adresse, von der die Anforderung gestellt wurde, wer die Anforderung gestellt hat, wann sie gestellt wurde, und zusätzliche Details.
Weitere Informationen CloudTrail dazu finden Sie im [AWS CloudTrail Benutzerhandbuch](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## Arbeiten mit Daten-API-Informationen in CloudTrail
CloudTrail ist in Ihrem AWS Konto aktiviert, wenn Sie das Konto erstellen. Wenn unterstützte Aktivitäten (Verwaltungsereignisse) in der Daten-API auftreten, wird diese Aktivität zusammen mit anderen AWS Serviceereignissen im **Ereignisverlauf in einem CloudTrail Ereignis** aufgezeichnet. Sie können aktuelle Verwaltungsereignisse in Ihrem AWS Konto anzeigen, suchen und herunterladen. Weitere Informationen finden Sie im *AWS CloudTrail Benutzerhandbuch unter [Arbeiten mit dem CloudTrail Ereignisverlauf](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).*
Für eine fortlaufende Aufzeichnung der Ereignisse in Ihrem AWS Konto, einschließlich der Ereignisse für die Daten-API, erstellen Sie einen Trail. Ein *Trail* ermöglicht CloudTrail die Übermittlung von Protokolldateien an einen Amazon S3 S3-Bucket. Wenn Sie einen Trail in der Konsole erstellen, gilt der Trail standardmäßig für alle AWS Regionen. Der Trail protokolliert Ereignisse aus allen AWS Regionen der AWS Partition und übermittelt die Protokolldateien an den von Ihnen angegebenen Amazon S3 S3-Bucket. Darüber hinaus können Sie andere AWS Dienste konfigurieren, um die in den CloudTrail Protokollen gesammelten Ereignisdaten weiter zu analysieren und darauf zu reagieren. Weitere Informationen finden Sie in folgenden Themen im *AWS CloudTrail -Benutzerhandbuch*:
+ [Übersicht zum Erstellen eines Trails](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail unterstützte Dienste und Integrationen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Konfiguration von Amazon SNS SNS-Benachrichtigungen für CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Empfangen von CloudTrail Protokolldateien aus mehreren Regionen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) und [Empfangen von CloudTrail Protokolldateien von mehreren Konten](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
Alle Daten-API-Operationen werden von der [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/Welcome.html) protokolliert CloudTrail und dokumentiert. Beispielsweise generieren Aufrufe der `ExecuteStatement` Operationen `BatchExecuteStatement``BeginTransaction`,`CommitTransaction`, und Einträge in den CloudTrail Protokolldateien.
Jeder Ereignis- oder Protokolleintrag enthält Informationen zu dem Benutzer, der die Anforderung generiert hat. Die Identitätsinformationen unterstützen Sie bei der Ermittlung der folgenden Punkte:
+ Ob die Anforderung mit Root- oder -Benutzeranmeldeinformationen ausgeführt wurde.
+ Gibt an, ob die Anforderung mit temporären Sicherheitsanmeldeinformationen für eine Rolle oder einen Verbundbenutzer gesendet wurde.
+ Ob die Anfrage von einem anderen AWS Dienst gestellt wurde.
Weitere Informationen finden Sie unter [CloudTrail -Element userIdentity](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
## Einbeziehen und Ausschließen von Daten-API-Ereignissen aus einem AWS CloudTrail Trail
Die meisten Daten-API-Benutzer verlassen sich auf die Ereignisse in einem AWS CloudTrail Trail, um eine Aufzeichnung der Daten-API-Operationen bereitzustellen. Die Ereignisdaten geben weder den Namen der Datenbank noch den Namen des Schemas oder die SQL-Anweisungen in Anforderungen an die Daten-API preis. Wenn Sie jedoch wissen, welcher Benutzer zu einem bestimmten Zeitpunkt eine Typ von Aufruf für einen bestimmten DB-Cluster durchgeführt hat, kann dies dazu beitragen, anomale Zugriffsmuster zu erkennen.
### Einbeziehen von Daten-API-Ereignissen in einen AWS CloudTrail Trail
*Für Aurora PostgreSQL Serverless v2 und bereitgestellte Datenbanken werden die folgenden Daten-API-Operationen als Datenereignisse protokolliert. AWS CloudTrail * [Datenereignisse](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html#logging-data-events) sind API-Operationen mit hohem Volumen auf Datenebene, die CloudTrail standardmäßig nicht protokolliert werden. Für Datenereignisse werden zusätzliche Gebühren fällig. [Informationen zur Preisgestaltung finden Sie unter CloudTrail AWS CloudTrail Preisgestaltung.](https://aws.amazon.com/cloudtrail/pricing/)
+ [BatchExecuteStatement](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BatchExecuteStatement.html)
+ [BeginTransaction](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BeginTransaction.html)
+ [CommitTransaction](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_CommitTransaction.html)
+ [ExecuteStatement](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html)
+ [RollbackTransaction](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_RollbackTransaction.html)
Sie können die CloudTrail Konsolen- oder CloudTrail API-Operationen verwenden AWS CLI, um diese Daten-API-Operationen zu protokollieren. Wählen Sie in der CloudTrail Konsole **RDS Data API — DB Cluster** als Datenereignistyp aus. Weitere Informationen finden Sie unter [Protokollieren von Datenereignissen mit der AWS-Managementkonsole](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html#creating-data-event-selectors-with-the-AWS-CLI) im *Benutzerhandbuch zu AWS CloudTrail *.
Führen Sie mit dem den `aws cloudtrail put-event-selectors` Befehl aus AWS CLI, um diese Daten-API-Operationen für Ihren Trail zu protokollieren. Um alle Daten-API-Ereignisse auf DB-Clustern zu protokollieren, geben Sie `AWS::RDS::DBCluster` als Ressourcentyp an. Im folgenden Beispiel werden alle Daten-API-Ereignisse auf DB-Clustern protokolliert. Weitere Informationen finden Sie unter [Protokollieren von Datenereignissen mit der AWS Command Line Interface](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail-by-using-the-aws-cli.html) im *Benutzerhandbuch für AWS CloudTrail *.
```
aws cloudtrail put-event-selectors --trail-name trail_name --advanced-event-selectors \
'{
"Name": "RDS Data API Selector",
"FieldSelectors": [
{
"Field": "eventCategory",
"Equals": [
"Data"
]
},
{
"Field": "resources.type",
"Equals": [
"AWS::RDS::DBCluster"
]
}
]
}'
```
Sie können erweiterte Ereignisauswahlen so konfigurieren, dass sie zusätzlich nach den Feldern `readOnly`, `eventName,` und `resources.ARN` gefiltert werden. Weitere Informationen zu diesen Feldern finden Sie unter [AdvancedFieldSelector](https://docs.aws.amazon.com/awscloudtrail/latest/APIReference/API_AdvancedFieldSelector.html).
### Daten-API-Ereignisse von einem AWS CloudTrail Trail ausschließen (Aurora Serverless v1nur)
Für Aurora Serverless v1 sind Daten-API-Aufrufe Verwaltungsereignisse. Standardmäßig sind alle Daten-API-Ereignisse in einem AWS CloudTrail Trail enthalten. Da die Daten-API jedoch eine große Anzahl von Ereignissen generieren kann, sollten Sie diese Ereignisse möglicherweise von Ihrem CloudTrail Trail ausschließen. Die Einstellung **Amazon-RDS-Daten-API-Ereignisse ausschließen** schließt alle Daten-API-Ereignisse aus dem Trail aus. Sie können bestimmte Daten-API-Ereignisse nicht ausschließen.
Zum Ausschließen von Daten-API-Ereignissen aus einem Trail führen Sie die folgenden Schritte aus:
+ Wählen Sie in der CloudTrail Konsole die Einstellung **Amazon RDS-Daten-API-Ereignisse ausschließen**, wenn Sie [einen Trail erstellen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html) oder [einen Trail aktualisieren](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-update-a-trail-console.html).
+ Verwenden Sie in der CloudTrail API den [PutEventSelectors](https://docs.aws.amazon.com/awscloudtrail/latest/APIReference/API_PutEventSelectors.html)Vorgang. Wenn Sie erweiterte Ereignisauswahlen verwenden, können Sie Daten-API-Ereignisse ausschließen, indem Sie das Feld `eventSource` so festlegen, dass es nicht gleich `rdsdata.amazonaws.com` ist. Wenn Sie erweiterte Ereignisauswahlen verwenden, können Sie Daten-API-Ereignisse ausschließen, indem Sie das Attribut `ExcludeManagementEventSources` auf `rdsdata.amazonaws.com` festlegen. Weitere Informationen finden Sie unter [Protokollieren von Ereignissen über die AWS Command Line Interface](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-events-with-cloudtrail.html#creating-mgmt-event-selectors-with-the-AWS-CLI) im *Benutzerhandbuch für AWS CloudTrail *.
**Warnung**
Das Ausschließen von Daten-API-Ereignissen aus einem CloudTrail Protokoll kann Daten-API-Aktionen verschleiern. Seien Sie vorsichtig, wenn Sie Prinzipalen die `cloudtrail:PutEventSelectors`-Berechtigung erteilen, die zum Ausführen dieses Vorgangs erforderlich ist.
Sie können diesen Ausschluss jederzeit deaktivieren, indem Sie die Konsoleneinstellung oder die Ereignisselektoren für einen Trail ändern. Der Trail beginnt dann mit der Aufzeichnung von Daten-API-Ereignissen. Er kann jedoch keine Daten-API-Ereignisse wiederherstellen, die aufgetreten sind, während der Ausschluss wirksam war.
Wenn Sie Daten-API-Ereignisse mithilfe der Konsole oder der API ausschließen, wird der daraus resultierende CloudTrail `PutEventSelectors` API-Vorgang auch in Ihren CloudTrail Protokollen protokolliert. Wenn Daten-API-Ereignisse nicht in Ihren CloudTrail Protokollen erscheinen, suchen Sie nach einem `PutEventSelectors` Ereignis, bei dem das `ExcludeManagementEventSources` Attribut auf gesetzt ist`rdsdata.amazonaws.com`.
Weitere Informationen finden Sie unter [Protokollieren von Managementereignissen für Trails](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-events-with-cloudtrail.html) im *AWS CloudTrail -Benutzerhandbuch.*
## Grundlegendes zu Data API-Protokolldateieinträgen
Ein *Trail* ist eine Konfiguration, die die Übertragung von Ereignissen als Protokolldateien an einen von Ihnen angegebenen Amazon S3 S3-Bucket ermöglicht. CloudTrail Protokolldateien enthalten einen oder mehrere Protokolleinträge. Ein *Ereignis* stellt eine einzelne Anforderung aus einer beliebigen Quelle dar und enthält Informationen über die angeforderte Aktion, Datum und Uhrzeit der Aktion, Anforderungsparameter usw. CloudTrail Protokolldateien sind kein geordneter Stack-Trace der öffentlichen API-Aufrufe, sodass sie nicht in einer bestimmten Reihenfolge angezeigt werden.
**Aurora PostgreSQL Serverless v2 und bereitgestellt**
Das folgende Beispiel zeigt einen CloudTrail Protokolleintrag, der den `ExecuteStatement` Betrieb für Aurora PostgreSQL Serverless v2 und bereitgestellte Datenbanken demonstriert. Für diese Datenbanken sind alle Daten-API-Ereignisse Datenereignisse, bei denen die Ereignisquelle **rdsdataapi.amazonaws.com** und der Ereignistyp **RDS-Daten-Service** lautet.
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE",
"arn": "arn:aws:iam::123456789012:user/johndoe",
"accountId": "123456789012",
"accessKeyId": "AKIAI44QH8DHBEXAMPLE",
"userName": "johndoe"
},
"eventTime": "2019-12-18T00:49:34Z",
"eventSource": "rdsdataapi.amazonaws.com",
"eventName": "ExecuteStatement",
"awsRegion": "us-east-1",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.16.102 Python/3.7.2 Windows/10 botocore/1.12.92",
"requestParameters": {
"continueAfterTimeout": false,
"database": "**********",
"includeResultMetadata": false,
"parameters": [],
"resourceArn": "arn:aws:rds:us-east-1:123456789012:cluster:my-database-1",
"schema": "**********",
"secretArn": "arn:aws:secretsmanager:us-east-1:123456789012:secret:dataapisecret-ABC123",
"sql": "**********"
},
"responseElements": null,
"requestID": "6ba9a36e-b3aa-4ca8-9a2e-15a9eada988e",
"eventID": "a2c7a357-ee8e-4755-a0d0-aed11ed4253a",
"eventType": "Rds Data Service",
"recipientAccountId": "123456789012"
}
```
**Aurora Serverless v1**
Das folgende Beispiel zeigt, wie der vorherige CloudTrail Beispielprotokolleintrag für aussieht. Aurora Serverless v1 Denn alle Ereignisse sind VerwaltungsereignisseAurora Serverless v1, bei denen die Ereignisquelle **rdsdata.amazonaws.com** und der Ereignistyp lautet. **AwsApiCall**
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE",
"arn": "arn:aws:iam::123456789012:user/johndoe",
"accountId": "123456789012",
"accessKeyId": "AKIAI44QH8DHBEXAMPLE",
"userName": "johndoe"
},
"eventTime": "2019-12-18T00:49:34Z",
"eventSource": "rdsdata.amazonaws.com",
"eventName": "ExecuteStatement",
"awsRegion": "us-east-1",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.16.102 Python/3.7.2 Windows/10 botocore/1.12.92",
"requestParameters": {
"continueAfterTimeout": false,
"database": "**********",
"includeResultMetadata": false,
"parameters": [],
"resourceArn": "arn:aws:rds:us-east-1:123456789012:cluster:my-database-1",
"schema": "**********",
"secretArn": "arn:aws:secretsmanager:us-east-1:123456789012:secret:dataapisecret-ABC123",
"sql": "**********"
},
"responseElements": null,
"requestID": "6ba9a36e-b3aa-4ca8-9a2e-15a9eada988e",
"eventID": "a2c7a357-ee8e-4755-a0d0-aed11ed4253a",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```
# Überwachen von RDS-Daten-API-Abfragen mit Performance Insights
Wenn Ihr Aurora-Cluster Aurora Serverless v2 oder bereitgestellte Instances ausführt, können Sie Performance Insights mit der RDS-Daten-API verwenden.
Weitere Informationen zur Verwendung von Performance Insights mit Aurora finden Sie unter [Überwachung mit Performance Insights auf ](USER_PerfInsights.md).
## So werden RDS-Daten-API-Abfragen in Performance Insights dargestellt
Mit der Daten-API verarbeitet Ihr Aurora-Cluster Abfragen basierend auf Daten-API-Aufrufen, die Sie über Ihre Anwendung übermitteln. Die Daten-API führt im Rahmen ihrer eigenen internen Abläufe auch einige SQL-Anweisungen aus, z. B. das Abbrechen von Abfragen, die den Timeout-Schwellenwert überschreiten. Beide Arten von SQL-Vorgängen werden in den Statistiken und Diagrammen von Performance Insights angezeigt.
+ Bei Daten-API-Abfragen, die Sie an einen Aurora-Cluster senden, ist das **Host**-Feld im PI-Dashboard als **RDS-Daten-API** gekennzeichnet. Für Aurora PostgreSQL hat das Feld **application\$1name** den Wert `rds-data-api`. Suchen Sie nach diesen Beschriftungen, wenn Sie die Datenbanklast mit den Dimensionen **Top-Hosts** oder **Top-Anwendungen** analysieren.
+ Alle internen Abfragen, die von der Daten-API ausgeführt werden, um Datenbankaspekte wie den Verbindungspool und Abfrage-Timeouts zu verwalten, sind mit dem Präfix **RDS-Daten-API** versehen. Beispiel: `/* RDS Data API */ select * from my_table;` Sucht nach diesen Präfixen, wenn Sie die Datenbanklast anhand von **Top SQL** als Dimension analysieren. Anweisungen werden mit einem SQL-Kommentar von `/* RDS Data API */` versehen.