Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan Amazon RDS Data API
Dengan menggunakan RDS Data API (Data API), Anda dapat bekerja dengan antarmuka layanan web ke cluster Aurora DB Anda. Data API tidak memerlukan koneksi persisten ke cluster DB. Sebaliknya, ia menyediakan titik akhir HTTP yang aman dan integrasi dengan AWS SDKs. Anda dapat menggunakan titik akhir untuk menjalankan pernyataan SQL tanpa mengelola koneksi.
Pengguna tidak perlu meneruskan kredensional dengan panggilan ke Data API, karena Data API menggunakan kredenal database yang disimpan di dalamnya. AWS Secrets Manager Untuk menyimpan kredensi di Secrets Manager, pengguna harus diberikan izin yang sesuai untuk menggunakan Secrets Manager, dan juga Data API. Lihat informasi selengkapnya tentang mengizinkan pengguna di [Mengotorisasi akses ke Amazon RDS Data API](data-api.access.md).
Anda juga dapat menggunakan Data API untuk mengintegrasikan Amazon Aurora dengan AWS aplikasi lain seperti AWS Lambda, AWS AppSync, dan. AWS Cloud9 Data API menyediakan cara yang lebih aman untuk digunakan AWS Lambda. API ini memungkinkan Anda mengakses klaster basis data tanpa perlu mengonfigurasi fungsi Lambda untuk mengakses sumber daya di cloud privat virtual (VPC). Lihat informasi selengkapnya di [AWS Lambda](https://aws.amazon.com/lambda/), [AWS AppSync](https://aws.amazon.com/appsync/), dan [AWS Cloud9](https://aws.amazon.com/cloud9/).
Anda dapat mengaktifkan Data API saat membuat cluster Aurora DB. Anda juga dapat mengubah konfigurasinya di lain waktu. Untuk informasi selengkapnya, lihat [Mengaktifkan API Data Amazon RDS](data-api.enabling.md).
Setelah mengaktifkan Data API, Anda juga dapat menggunakan editor kueri untuk menjalankan kueri ad hoc tanpa mengonfigurasi alat kueri untuk mengakses Aurora di VPC. Lihat informasi yang lebih lengkap di [Menggunakan editor kueri Aurora](query-editor.md).
**Topics**
+ [Ketersediaan wilayah dan versi untuk Amazon RDS Data API](data-api.regions.md)
+ [Menggunakan IPv6 dengan Amazon RDS Data API](data-api.ipv6.md)
+ [Batasan untuk Amazon RDS Data API](data-api.limitations.md)
+ [Membandingkan perilaku Amazon RDS Data API untuk Aurora Serverless v2 dan klaster yang disediakan dengan cluster Aurora Serverless v1](data-api.differences.md)
+ [Mengotorisasi akses ke Amazon RDS Data API](data-api.access.md)
+ [Mengaktifkan API Data Amazon RDS](data-api.enabling.md)
+ [Membuat titik akhir VPC Amazon untuk Amazon RDS Data API ()AWS PrivateLink](data-api.vpc-endpoint.md)
+ [Memanggil Amazon RDS Data API](data-api.calling.md)
+ [Menggunakan pustaka klien Java untuk RDS Data API](data-api.java-client-library.md)
+ [Memproses hasil kueri Amazon RDS Data API dalam format JSON](data-api-json.md)
+ [Memecahkan Masalah Amazon RDS Data API](data-api.troubleshooting.md)
+ [Mencatat panggilan Amazon RDS Data API dengan AWS CloudTrail](logging-using-cloudtrail-data-api.md)
+ [Memantau kueri API Data RDS dengan Performance Insights](monitoring-using-performance-insights-data-api.md)
# Ketersediaan wilayah dan versi untuk Amazon RDS Data API
Untuk informasi tentang Wilayah dan versi engine yang tersedia untuk Data API, lihat bagian berikut.
| Jenis cluster | Wilayah dan ketersediaan versi |
| --- | --- |
| Aurora PostgreSQL disediakan dan Serverless v2 | [Data API dengan Aurora PostgreSQL Serverless v2 dan disediakan](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.md#Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.apg) |
| Aurora MySQL disediakan dan Serverless v2 | [API data dengan Aurora MySQL Serverless v2 dan disediakan](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.md#Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.ams) |
| Aurora PostgreSQL Tanpa Server v1 | [API Data dengan 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 Tanpa Server v1 | [API Data dengan Aurora MySQL Serverless v1](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.md#Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.amy) |
Jika Anda memerlukan modul kriptografi yang divalidasi oleh FIPS 140-2 saat mengakses Data API melalui antarmuka baris perintah atau API, gunakan titik akhir FIPS. Lihat informasi selengkapnya tentang titik akhir FIPS yang tersedia di [Standar Pemrosesan Informasi Federal (FIPS) 140-2](https://aws.amazon.com/compliance/fips/).
# Menggunakan IPv6 dengan Amazon RDS Data API
Amazon RDS Data API mendukung IPv6 konektivitas melalui titik akhir dual-stack. Ini memungkinkan Anda untuk terhubung ke Data API menggunakan IPv6 alamat sambil mempertahankan kompatibilitas mundur dengan IPv4.
## IPv6 dukungan endpoint
Data API menyediakan titik akhir dual-stack yang mendukung keduanya IPv4 dan koneksi. IPv6 Endpoint ini menggunakan `.aws` domain alih-alih `.amazonaws.com` domain tradisional.
### Jenis titik akhir yang tersedia
Titik akhir tumpukan ganda publik
Format: `rds-data.region.api.aws`
Contoh: `rds-data.us-east-1.api.aws`
Titik akhir tumpukan ganda FIPS
Format: `rds-data-fips.region.api.aws`
Contoh: `rds-data-fips.us-east-1.api.aws`
PrivateLink IPv6 titik akhir
Tersedia melalui titik akhir VPC dengan dukungan IPv6
Memungkinkan IPv6 konektivitas pribadi dalam VPC Anda
### Titik akhir hanya warisan IPv4
`.amazonaws.com`Titik akhir yang ada terus mendukung koneksi IPv4 -only:
+ `rds-data.region.amazonaws.com`
+ `rds-data-fips.region.amazonaws.com`
**catatan**
Titik akhir lama tetap tidak berubah untuk memastikan kompatibilitas mundur dengan aplikasi yang ada.
## Menggunakan titik IPv6 akhir
Untuk menggunakan IPv6 Data API, perbarui aplikasi Anda untuk menggunakan titik akhir dual-stack baru. Aplikasi Anda akan secara otomatis digunakan IPv6 jika tersedia, atau kembali ke IPv4.
Untuk panduan umum tentang pengaturan IPv6 di VPC Anda, lihat [Memigrasi ke](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-migrate-ipv6.html) dalam Panduan IPv6 Pengguna Amazon *VPC*.
Anda dapat mengonfigurasi IPv6 titik akhir dengan dua cara:
+ **Menggunakan variabel lingkungan: Atur** `AWS_USE_DUALSTACK_ENDPOINT=true` di IPv6 lingkungan Anda. The AWS CLI and AWS SDKs akan secara otomatis membangun `api.aws` endpoint yang sesuai tanpa mengharuskan Anda untuk menentukan URLs endpoint secara manual.
+ **Menggunakan titik akhir eksplisit URLs: Tentukan URL titik akhir** tumpukan ganda secara langsung di AWS CLI perintah atau konfigurasi SDK Anda seperti yang ditunjukkan pada contoh di bawah ini.
### AWS CLI konfigurasi
Konfigurasikan IPv6 titik akhir AWS CLI untuk menggunakan dengan menentukan URL titik akhir:
Untuk Linux, macOS, atau 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"
```
Untuk 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 Konfigurasi SDK
Konfigurasikan AWS SDKs untuk menggunakan titik akhir dual-stack:
------
#### [ 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);
```
------
## Menggunakan AWS PrivateLink dengan IPv6
Anda dapat membuat titik akhir VPC untuk Data API yang mendukung IPv6 konektivitas dalam VPC Anda. Untuk petunjuk mendetail tentang cara membuat titik akhir VPC untuk Data API, lihat. [Membuat titik akhir VPC Amazon untuk Amazon RDS Data API ()AWS PrivateLink](data-api.vpc-endpoint.md)
Saat membuat titik akhir VPC untuk IPv6 dukungan, pastikan bahwa:
+ VPC dan subnet Anda dikonfigurasi untuk mendukung IPv6
+ Grup keamanan memungkinkan IPv6 lalu lintas pada port yang diperlukan (biasanya 443 untuk HTTPS)
+ Jaringan ACLs dikonfigurasi untuk memungkinkan IPv6 lalu lintas
## Pertimbangan migrasi
Saat bermigrasi ke IPv6 titik akhir, pertimbangkan hal berikut:
+ **Migrasi bertahap**: Anda dapat memigrasikan aplikasi secara bertahap dengan memperbarui titik akhir URLs satu aplikasi pada satu waktu.
+ **Kompatibilitas jaringan**: Pastikan infrastruktur jaringan Anda mendukung IPv6 sebelum bermigrasi.
+ **Kebijakan keamanan**: Perbarui aturan grup keamanan dan jaringan ACLs untuk mengizinkan IPv6 lalu lintas jika diperlukan.
+ **Pemantauan**: Perbarui konfigurasi pemantauan dan pencatatan untuk menangani IPv6 alamat.
**catatan**
**Alamat koneksi database**: Saat menggunakan IPv6 titik akhir untuk Data API, koneksi database yang mendasari dan log database akan tetap menampilkan IPv4 alamat. Ini adalah perilaku yang diharapkan dan tidak memengaruhi fungsionalitas aplikasi Anda IPv6 yang diaktifkan.
## Memecahkan masalah konektivitas IPv6
Jika Anda mengalami masalah dengan IPv6 konektivitas, periksa hal berikut:
Konfigurasi jaringan
Verifikasi bahwa jaringan Anda mendukung IPv6 dan bahwa IPv6 routing dikonfigurasi dengan benar.
Resolusi DNS
Pastikan bahwa resolver DNS Anda dapat menyelesaikan catatan AAAA untuk titik akhir dual-stack.
Grup keamanan
Perbarui aturan grup keamanan untuk mengizinkan IPv6 lalu lintas pada port yang diperlukan (biasanya 443 untuk HTTPS).
Pustaka klien
Verifikasi bahwa pustaka klien HTTP Anda mendukung IPv6 dan konektivitas dual-stack.
# Batasan untuk Amazon RDS Data API
RDS Data API memiliki batasan sebagai berikut:
+ Anda hanya dapat menjalankan kueri Data API pada instance penulis di cluster DB. Namun, instance penulis dapat menerima kueri tulis dan baca.
+ Dengan database global Aurora, Anda dapat mengaktifkan Data API pada cluster DB primer dan sekunder. Namun, cluster sekunder tidak memiliki instance penulis sampai dipromosikan menjadi yang utama. Data API memerlukan akses ke instance penulis untuk pemrosesan kueri, bahkan untuk kueri baca. Akibatnya, kueri baca dan tulis yang dikirim ke cluster sekunder gagal sementara tidak memiliki instance penulis. Setelah cluster sekunder dipromosikan dan memiliki instance penulis yang tersedia, kueri Data API pada instans DB tersebut berhasil.
+ Data API tidak didukung pada kelas instans T DB.
+ Untuk Aurora Serverless v2 dan menyediakan kluster DB, RDS Data API tidak mendukung beberapa tipe data. Untuk daftar tipe yang didukung, lihat[Membandingkan perilaku Amazon RDS Data API untuk Aurora Serverless v2 dan klaster yang disediakan dengan cluster Aurora Serverless v1](data-api.differences.md).
+ Untuk Aurora PostgreSQL versi 14 dan database yang lebih tinggi, Data API hanya mendukung enkripsi kata sandi. `scram-sha-256`
+ Batas ukuran respons adalah 1 MiB. Jika panggilan menghasilkan data respons dengan ukuran lebih dari 1 MiB, panggilan tersebut akan diakhiri.
+ UntukAurora Serverless v1, jumlah maksimum permintaan per detik adalah 1.000. Untuk semua database lain yang didukung, tidak ada batasan.
+ Batas ukuran API Data adalah 64 KB per baris dalam set hasil yang ditampilkan oleh basis data. Pastikan bahwa setiap baris dalam set hasil adalah 64 KB atau kurang.
# Membandingkan perilaku Amazon RDS Data API untuk Aurora Serverless v2 dan klaster yang disediakan dengan cluster Aurora Serverless v1
Peningkatan terbaru untuk Amazon RDS Data APIs membuat Data APIs tersedia untuk cluster yang menggunakan versi terbaru dari PostgreSQL atau mesin MySQL. Cluster ini dapat dikonfigurasi untuk menggunakan Aurora Serverless v2 atau menyediakan kelas instance seperti atau. `db.r6g` `db.r6i`
Bagian berikut menjelaskan perbedaan Amazon RDS Data API antara Aurora Serverless v2 dan kluster DB yang disediakan, dan kluster DB. Aurora Serverless v1 Aurora Serverless v1 Cluster DB menggunakan mode `serverless` mesin. Cluster DB yang disediakan menggunakan mode mesin. `provisioned` Cluster Aurora Serverless v2 DB juga menggunakan mode `provisioned` engine, dan berisi satu atau lebih instance Aurora Serverless v2 DB dengan kelas `db.serverless` instance.
## Jumlah maksimum permintaan per detik
**Aurora Serverless v1**
Data APIs dapat membuat hingga 1.000 permintaan per detik.
**Aurora Serverless v2**
Data APIs dapat membuat jumlah permintaan per detik yang tidak terbatas.
## Mengaktifkan atau menonaktifkan Amazon RDS Data API pada database yang ada
**Aurora Serverless v1**
+ **Dengan Amazon RDS API** — Gunakan `ModifyCluster` operasi dan tentukan `True` atau`False`, sebagaimana berlaku, untuk `EnableHttpEndpoint` parameter.
+ **Dengan AWS CLI** — Gunakan `modify-db-cluster` operasi dengan `--no-enable-http-endpoint` opsi `--enable-http-endpoint` atau, sebagaimana berlaku.
**Aurora Serverless v2**
+ **Dengan Amazon RDS API** — Gunakan `EnableHttpEndpoint` dan `DisableHttpEndpoint` operasi.
+ **Dengan:Gunakan** dan AWS CLI`enable-http-endpoint` operasi. `disable-http-endpoint`
## CloudTrail acara
**Aurora Serverless v1**
Peristiwa dari panggilan API Data adalah peristiwa manajemen. Peristiwa ini secara otomatis disertakan dalam jejak secara default. Untuk informasi selengkapnya, lihat [Mengecualikan peristiwa Data API dari AWS CloudTrail jejak (Aurora Serverless v1hanya)](logging-using-cloudtrail-data-api.md#logging-using-cloudtrail-data-api.excluding-cloudtrail-events).
**Aurora Serverless v2**
Peristiwa dari panggilan API Data adalah peristiwa data. Peristiwa ini secara otomatis dikecualikan dalam jejak secara default. Untuk informasi selengkapnya, lihat [Menyertakan peristiwa API Data dalam suatu AWS CloudTrail jejak](logging-using-cloudtrail-data-api.md#logging-using-cloudtrail-data-api.including-cloudtrail-events).
## Dukungan multistatement
**Aurora Serverless v1**
+ Untuk Aurora MySQL, multistatement tidak didukung.
+ Untuk Aurora PostgreSQL, multistatement hanya mengembalikan respons kueri pertama.
**Aurora Serverless v2**
Multistatement tidak didukung. Mencoba mengeksekusi beberapa pernyataan dalam satu panggilan API kembali`“An error occurred (ValidationException) when calling the ExecuteStatement operation: Multistatements aren't supported.”`. Untuk mengeksekusi beberapa pernyataan, buat panggilan `ExecuteStatement` API terpisah atau gunakan `BatchExecuteStatement` untuk pemrosesan batch.
Contoh berikut menunjukkan pesan kesalahan yang dihasilkan dari panggilan API yang mencoba mengeksekusi multistatement.
```
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.
```
Contoh berikut mengeksekusi beberapa pernyataan dengan panggilan `ExecuteStatement` API terpisah.
```
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;"
```
## Permintaan bersamaan untuk ID transaksi yang sama
**Aurora Serverless v1**
Permintaan selanjutnya menunggu hingga permintaan saat ini selesai. Aplikasi Anda perlu menangani kesalahan batas waktu jika masa tunggu terlalu lama.
**Aurora Serverless v2**
Ketika Data API menerima beberapa permintaan dengan ID transaksi yang sama, ia segera mengembalikan kesalahan ini:
`DatabaseErrorException: Transaction is still running a query`
Kesalahan ini terjadi dalam dua situasi:
+ Aplikasi Anda membuat permintaan asinkron (seperti JavaScript janji) menggunakan ID transaksi yang sama.
+ Permintaan sebelumnya dengan ID transaksi tersebut masih diproses.
Contoh berikut menunjukkan semua permintaan dieksekusi secara paralel dengan`promise.all()`.
```
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);
```
Untuk mengatasi kesalahan ini, tunggu permintaan saat ini selesai sebelum mengirim permintaan lain dengan ID transaksi yang sama atau hapus ID transaksi untuk mengizinkan permintaan paralel.
Contoh berikut menunjukkan panggilan API yang menggunakan eksekusi sekuensial dengan ID transaksi yang sama.
```
for (let i = 0; i < 10; i++) {
await client.send(
new ExecuteStatementCommand({
...params,
sql: `insert into table_name values (i);`,
transactionId
})
).promise()
);
}
```
## BatchExecuteStatement perilaku
Untuk informasi selengkapnya tentang `BatchExecuteStatement`, lihat [BatchExecuteStatement](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BatchExecuteStatement.html).
**Aurora Serverless v1**
Objek bidang yang dihasilkan dalam hasil pembaruan mencakup nilai yang disisipkan.
**Aurora Serverless v2**
+ Untuk Aurora MySQL, objek bidang yang dihasilkan dalam hasil pembaruan mencakup nilai yang disisipkan.
+ Untuk Aurora PostgreSQL, objek bidang yang dihasilkan kosong.
## Eksekusi perilaku QL
Untuk informasi selengkapnya`ExecuteSQL`, lihat [ExecuteSQL](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteSql.html).
**Aurora Serverless v1**
`ExecuteSQL`Operasi ini tidak digunakan lagi.
**Aurora Serverless v2**
`ExecuteSQL`Operasi tidak didukung.
## ExecuteStatement perilaku
Untuk informasi selengkapnya tentang `ExecuteStatement`, lihat [ExecuteStatement](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html).
**Aurora Serverless v1**
`ExecuteStatement`Parameter mendukung pengambilan kolom array multidimensi dan semua tipe data lanjutan.
**Aurora Serverless v2**
`ExecuteStatement`Parameter tidak mendukung kolom array multidimensi. Ini juga tidak mendukung tipe data PostgreSQL tertentu, termasuk tipe geometris dan moneter. Ketika API Data menemukan tipe data yang tidak didukung, ia mengembalikan kesalahan ini—. `UnsupportedResultException: The result contains the unsupported data type data_type`
Untuk mengatasi masalah ini, kirimkan tipe data yang tidak didukung ke`TEXT`. Contoh berikut melemparkan tipe data yang tidak didukung ke. `TEXT`
```
SELECT custom_type::TEXT FROM my_table;--
ORSELECT CAST(custom_type AS TEXT) FROM my_table;
```
Untuk daftar tipe data yang didukung untuk setiap mesin database Aurora, lihat Referensi [operasi API Data](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html#data-api-operations).
## Perilaku parameter skema
**Aurora Serverless v1**
`Schema`Paramater tidak didukung. Saat Anda menyertakan `Schema` parameter dalam panggilan API, API Data akan mengabaikan parameter tersebut.
**Aurora Serverless v2**
`Schema`Parameter tidak digunakan lagi. Saat Anda menyertakan `Schema` parameter dalam panggilan API, API Data mengembalikan kesalahan ini—`ValidationException: The schema parameter isn't supported`. Contoh berikut menunjukkan panggilan Data API yang mengembalikan `ValidationException` kesalahan.
```
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"
```
Untuk mengatasi masalah ini, hapus `Schema` parameter dari panggilan API Anda.
Contoh berikut menunjukkan panggilan Data API dengan `Schema` parameter dihapus.
```
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"
```
# Mengotorisasi akses ke Amazon RDS Data API
Pengguna dapat menjalankan operasi Amazon RDS Data API (Data API) hanya jika mereka berwenang untuk melakukannya. Anda dapat memberikan izin kepada pengguna untuk menggunakan Data API dengan melampirkan kebijakan AWS Identity and Access Management (IAM) yang menentukan hak istimewa mereka. Anda juga dapat melampirkan kebijakan ini pada peran jika Anda menggunakan peran IAM. Kebijakan AWS terkelola`AmazonRDSDataFullAccess`, termasuk izin untuk API Data.
`AmazonRDSDataFullAccess`Kebijakan ini juga mencakup izin bagi pengguna untuk mendapatkan nilai rahasia. AWS Secrets Manager Pengguna perlu menggunakan Secrets Manager untuk menyimpan rahasia yang dapat mereka gunakan dalam panggilan mereka ke Data API. Menggunakan rahasia berarti bahwa pengguna tidak perlu menyertakan kredensi database untuk sumber daya yang mereka targetkan dalam panggilan mereka ke Data API. Data API secara transparan memanggil Secrets Manager, yang memungkinkan (atau menyangkal) permintaan pengguna untuk rahasia tersebut. Untuk informasi tentang menyiapkan rahasia yang akan digunakan dengan Data API, lihat[Menyimpan kredensi basis data di AWS Secrets Manager](#data-api.secrets).
`AmazonRDSDataFullAccess`Kebijakan ini menyediakan akses lengkap (melalui Data API) ke sumber daya. Anda dapat mempersempit cakupan dengan menentukan kebijakan Anda sendiri yang menentukan Amazon Resource Name (ARN) sumber daya.
Misalnya, kebijakan berikut menunjukkan contoh izin minimum yang diperlukan bagi pengguna untuk mengakses Data API untuk klaster DB yang diidentifikasi oleh ARN-nya. Kebijakan tersebut mencakup izin yang diperlukan untuk mengakses Secrets Manager dan mendapatkan otorisasi ke instans basis data untuk pengguna.
------
#### [ 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"
}
]
}
```
------
Kami menyarankan agar Anda menggunakan ARN khusus untuk elemen "Sumber Daya" dalam pernyataan kebijakan Anda (seperti yang ditunjukkan dalam contoh), bukan karakter wildcard (\$1).
## Bekerja dengan otorisasi berbasis tag
RDS Data API (Data API) dan Secrets Manager keduanya mendukung otorisasi berbasis tag. *Tag* adalah pasangan nilai kunci yang melabeli sumber daya, seperti klaster RDS, dengan nilai string tambahan, misalnya:
+ `environment:production`
+ `environment:development`
Anda dapat menerapkan tag ke sumber daya Anda untuk alokasi biaya, dukungan operasi, kontrol akses, dan banyak alasan lainnya. (Jika Anda belum memiliki tag pada sumber daya dan ingin menerapkannya, Anda dapat mempelajari lebih lanjut di [Memberi tag pada sumber daya Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html).) Anda dapat menggunakan tag dalam pernyataan kebijakan Anda untuk membatasi akses ke klaster RDS yang dilabeli tag ini. Sebagai contoh, klaster basis data Aurora mungkin memiliki tag yang mengidentifikasi lingkungannya sebagai produksi atau pengembangan.
Contoh-contoh berikut menunjukkan bagaimana Anda dapat menggunakan tag dalam pernyataan kebijakan Anda. Pernyataan ini mengharuskan klaster dan rahasia yang diteruskan dalam permintaan API Data memiliki tag `environment:production`.
Begini cara kebijakan diterapkan: Saat pengguna melakukan panggilan menggunakan Data API, permintaan akan dikirim ke layanan. Data API pertama-tama memverifikasi bahwa ARN cluster yang diteruskan dalam permintaan ditandai dengan. `environment:production` API ini kemudian memanggil Secrets Manager untuk mengambil nilai rahasia pengguna dalam permintaan tersebut. Secrets Manager juga memverifikasi bahwa rahasia pengguna ditandai dengan `environment:production`. Jika demikian, API Data kemudian menggunakan nilai yang diambil untuk kata sandi basis data pengguna. Terakhir, jika itu juga benar, permintaan API Data berhasil diinvokasi untuk pengguna.
------
#### [ 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"
]
}
}
}
]
}
```
------
Contoh menunjukkan tindakan terpisah untuk `rds-data` dan `secretsmanager` untuk Data API dan Secrets Manager. Namun, Anda dapat menggabungkan tindakan dan menentukan kondisi tag dengan berbagai cara untuk mendukung kasus penggunaan spesifik Anda. Lihat informasi selengkapnya di [Menggunakan kebijakan berbasis identitas (kebijakan IAM) untuk Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access_identity-based-policies.html#permissions_grant-limited-condition).
Di elemen "Kondisi" kebijakan, Anda dapat memilih kunci tag dari beberapa pilihan berikut:
+ `aws:TagKeys`
+ `aws:ResourceTag/${TagKey}`
Untuk mempelajari lebih lanjut tentang tag sumber daya dan cara menggunakannya`aws:TagKeys`, lihat [Mengontrol akses ke AWS sumber daya menggunakan tag sumber daya](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html#access_tags_control-tag-keys).
**catatan**
Baik Data API dan AWS Secrets Manager otorisasi pengguna. Jika Anda tidak memiliki izin untuk semua tindakan yang ditentukan dalam kebijakan, Anda akan mendapatkan kesalahan `AccessDeniedException`.
## Menyimpan kredensi basis data di AWS Secrets Manager
Saat Anda memanggil Amazon RDS Data API (Data API), Anda meneruskan kredensi untuk klaster Aurora DB dengan menggunakan rahasia di Secrets Manager. Untuk memberikan kredensial dengan cara ini, Anda menentukan nama rahasia atau Amazon Resource Name (ARN) rahasia tersebut.
**Menyimpan kredensial klaster basis data dalam rahasia**
1. Gunakan Secrets Manager untuk membuat rahasia yang berisi kredensial untuk klaster basis data Aurora.
Lihat petunjuknya di [Membuat rahasia basis data](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html) dalam *Panduan Pengguna AWS Secrets Manager *.
1. Gunakan konsol Secrets Manager untuk melihat detail rahasia yang Anda buat, atau jalankan `aws secretsmanager describe-secret` AWS CLI perintah.
Catat nama dan ARN rahasia. Anda dapat menggunakannya dalam panggilan ke Data API.
Lihat informasi selengkapnya tentang menggunakan Secrets Manager di [Panduan Pengguna AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html).
Untuk memahami bagaimana Amazon Aurora mengelola Identity and Access Management, lihat [Bagaimana Amazon Aurora bekerja dengan IAM](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/security_iam_service-with-iam.html).
Lihat informasi selengkapnya tentang pembuatan kebijakan IAM di [Membuat Kebijakan IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) dalam *Panduan Pengguna IAM*. Lihat informasi tentang cara menambahkan kebijakan IAM ke pengguna di [Menambahkan dan Menghapus Izin Identitas IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dalam *Panduan Pengguna IAM*.
# Mengaktifkan API Data Amazon RDS
Untuk menggunakan Amazon RDS Data API (Data API), aktifkan untuk klaster Aurora DB Anda. Anda dapat mengaktifkan Data API saat membuat atau memodifikasi cluster DB.
**catatan**
Apakah Data API tersedia untuk klaster Anda tergantung pada versi Aurora, mesin database, dan AWS Wilayah Anda. Untuk versi Aurora yang lebih lama, Data API hanya berfungsi dengan Aurora Serverless v1 cluster. Untuk versi Aurora yang lebih baru, Data API bekerja dengan cluster yang menggunakan provisioned dan instance. Aurora Serverless v2 Untuk memeriksa apakah klaster Anda dapat menggunakan Data API, lihat[Daerah yang Didukung dan engine Aurora DB untuk RDS Data API](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Data_API.md).
**Topics**
+ [Mengaktifkan RDS Data API saat Anda membuat database](#data-api.enabling.creating)
+ [Mengaktifkan API Data RDS pada database yang ada](#data-api.enabling.modifying)
## Mengaktifkan RDS Data API saat Anda membuat database
Saat Anda membuat database yang mendukung RDS Data API (Data API), Anda dapat mengaktifkan fitur ini. Prosedur berikut menjelaskan cara melakukannya ketika Anda menggunakan Konsol Manajemen AWS, AWS CLI, atau RDS API.
### Konsol
Untuk mengaktifkan Data API saat Anda membuat cluster DB, pilih kotak centang **Aktifkan API Data RDS** di bagian **Konektivitas** pada halaman **Buat database**, seperti pada tangkapan layar berikut.
![\[Bagian Konektivitas pada halaman Buat database, dengan kotak centang Aktifkan API Data RDS dipilih.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/data-api-enable-on-create.png)
Untuk petunjuk tentang cara membuat klaster Aurora DB yang dapat menggunakan API Data RDS, lihat berikut ini:
+ Untuk Aurora Serverless v2 dan klaster yang disediakan - [Membuat klaster DB Amazon Aurora](Aurora.CreateInstance.md)
+ Untuk Aurora Serverless v1 - [Membuat Aurora Serverless v1 klaster DB.](aurora-serverless.create.md)
### AWS CLI
Untuk mengaktifkan Data API saat Anda membuat cluster Aurora DB, jalankan [create-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html) AWS CLI perintah dengan opsi. `--enable-http-endpoint`
Contoh berikut membuat cluster Aurora PostgreSQL DB dengan Data API diaktifkan.
Untuk Linux, macOS, atau Unix:
```
aws rds create-db-cluster \
--db-cluster-identifier my_pg_cluster \
--engine aurora-postgresql \
--enable-http-endpoint
```
Untuk Windows:
```
aws rds create-db-cluster ^
--db-cluster-identifier my_pg_cluster ^
--engine aurora-postgresql ^
--enable-http-endpoint
```
### API RDS
Untuk mengaktifkan Data API saat Anda membuat cluster Aurora DB, gunakan DBCluster operasi [Create](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html) dengan nilai `EnableHttpEndpoint` parameter yang disetel ke. `true`
## Mengaktifkan API Data RDS pada database yang ada
Anda dapat memodifikasi cluster DB yang mendukung RDS Data API (Data API) untuk mengaktifkan atau menonaktifkan fitur ini.
**Topics**
+ [Mengaktifkan atau menonaktifkan Data API (Aurora Serverless v2dan disediakan)](#data-api.enabling.modifying.all)
+ [Mengaktifkan atau menonaktifkan Data API (hanya) Aurora Serverless v1](#data-api.enabling.modifying.sv1)
### Mengaktifkan atau menonaktifkan Data API (Aurora Serverless v2dan disediakan)
Gunakan prosedur berikut untuk mengaktifkan atau menonaktifkan Data API pada Aurora Serverless v2 dan database yang disediakan. Untuk mengaktifkan atau menonaktifkan Data API pada Aurora Serverless v1 database, gunakan prosedur di[Mengaktifkan atau menonaktifkan Data API (hanya) Aurora Serverless v1](#data-api.enabling.modifying.sv1).
#### Konsol
Anda dapat mengaktifkan atau menonaktifkan Data API dengan menggunakan konsol RDS untuk cluster DB yang mendukung fitur ini. Untuk melakukannya, buka halaman detail cluster database tempat Anda ingin mengaktifkan atau menonaktifkan Data API, dan pada tab **Konektivitas & keamanan**, buka bagian **API Data RDS**. Bagian ini menampilkan status Data API, dan memungkinkan Anda untuk mengaktifkan atau menonaktifkannya.
Screenshot berikut menunjukkan bahwa **RDS Data API** tidak diaktifkan.
![\[Bagian API Data RDS pada tab Konektivitas dan keamanan halaman detail untuk cluster DB. Status Data API ditampilkan sebagai dinonaktifkan, dan tombol Aktifkan API Data RDS hadir.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/data-api-enable-from-details.png)
#### AWS CLI
Untuk mengaktifkan atau menonaktifkan Data API pada database yang ada, jalankan [disable-http-endpoint](https://docs.aws.amazon.com/cli/latest/reference/rds/disable-http-endpoint.html) AWS CLI perintah [enable-http-endpoint](https://docs.aws.amazon.com/cli/latest/reference/rds/enable-http-endpoint.html)or, dan tentukan ARN cluster DB Anda.
Contoh berikut memungkinkan Data API.
Untuk Linux, macOS, atau Unix:
```
aws rds enable-http-endpoint \
--resource-arn cluster_arn
```
Untuk Windows:
```
aws rds enable-http-endpoint ^
--resource-arn cluster_arn
```
#### API RDS
Untuk mengaktifkan atau menonaktifkan Data API pada database yang ada, gunakan [EnableHttpEndpoint](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_EnableHttpEndpoint.html)dan [DisableHttpEndpoint](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DisableHttpEndpoint.html)operasi.
### Mengaktifkan atau menonaktifkan Data API (hanya) Aurora Serverless v1
Gunakan prosedur berikut untuk mengaktifkan atau menonaktifkan Data API pada Aurora Serverless v1 database yang ada. Untuk mengaktifkan atau menonaktifkan Data API pada Aurora Serverless v2 dan database yang disediakan, gunakan prosedur di. [Mengaktifkan atau menonaktifkan Data API (Aurora Serverless v2dan disediakan)](#data-api.enabling.modifying.all)
#### Konsol
Saat memodifikasi cluster Aurora Serverless v1 DB, Anda mengaktifkan Data API di bagian **Konektivitas** konsol RDS.
Tangkapan layar berikut menunjukkan **API Data** yang diaktifkan saat memodifikasi cluster Aurora DB.
![\[Bagian Konektivitas pada halaman Modify DB Cluster, kotak centang Data API dipilih.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/data-api-modify-serverlessv1.png)
Untuk petunjuk tentang cara memodifikasi cluster Aurora Serverless v1 DB, lihat[Memodifikasi klaster DB Aurora Serverless v1](aurora-serverless.modifying.md).
#### AWS CLI
Untuk mengaktifkan atau menonaktifkan Data API, jalankan [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) AWS CLI perintah, dengan `--enable-http-endpoint` atau`--no-enable-http-endpoint`, sebagaimana berlaku.
Contoh berikut memungkinkan Data API aktif`sample-cluster`.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-cluster \
--db-cluster-identifier sample-cluster \
--enable-http-endpoint
```
Untuk Windows:
```
aws rds modify-db-cluster ^
--db-cluster-identifier sample-cluster ^
--enable-http-endpoint
```
#### API RDS
Untuk mengaktifkan Data API, gunakan DBCluster operasi [Modify](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html), dan tetapkan nilai `EnableHttpEndpoint` ke `true` atau`false`, sebagaimana berlaku.
# Membuat titik akhir VPC Amazon untuk Amazon RDS Data API ()AWS PrivateLink
Amazon VPC memungkinkan Anda meluncurkan AWS sumber daya, seperti cluster dan aplikasi Aurora DB, ke cloud pribadi virtual (VPC). AWS PrivateLink menyediakan konektivitas pribadi antara VPCs dan AWS layanan dengan keamanan tinggi di jaringan Amazon. Dengan menggunakan AWS PrivateLink, Anda dapat membuat titik akhir VPC Amazon, yang memungkinkan Anda terhubung ke layanan di berbagai akun dan VPCs berdasarkan Amazon VPC. Lihat informasi selengkapnya tentang AWS PrivateLink di [Layanan Titik Akhir VPC (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-service.html) dalam *Panduan Pengguna Amazon Virtual Private Cloud*.
Anda dapat memanggil RDS Data API (Data API) dengan titik akhir Amazon VPC. Menggunakan endpoint Amazon VPC menjaga lalu lintas antar aplikasi di Amazon VPC dan Data API di AWS jaringan, tanpa menggunakan alamat IP publik. Titik akhir Amazon VPC dapat membantu Anda memenuhi persyaratan kepatuhan dan peraturan yang berkaitan dengan membatasi konektivitas internet publik. Misalnya, jika Anda menggunakan titik akhir VPC Amazon, Anda dapat menjaga lalu lintas antara aplikasi yang berjalan pada instans Amazon EC2 dan Data API di dalamnya. VPCs
Setelah membuat titik akhir Amazon VPC, Anda dapat mulai menggunakannya tanpa membuat kode atau perubahan konfigurasi apa pun di aplikasi Anda.
**Untuk membuat titik akhir VPC Amazon untuk Data API**
1. Masuk ke Konsol Manajemen AWS dan buka konsol VPC Amazon di. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. Pilih **Titik Akhir**, lalu pilih **Buat Titik Akhir**.
1. Di halaman **Buat Titik Akhir**, untuk **Kategori layanan**, pilih **Layanan AWS **. Untuk **Nama Layanan**, pilih **rds-data**.
![\[Membuat endpoint Amazon VPC untuk Data API\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/data-api-create-endpoint.png)
1. Untuk **VPC**, pilih VPC tempat membuat titik akhir.
Pilih VPC yang berisi aplikasi yang membuat panggilan API Data.
1. Untuk **Subnet**, pilih subnet untuk setiap Availability Zone (AZ) yang digunakan oleh AWS layanan yang menjalankan aplikasi Anda.
![\[Pilih subnet untuk titik akhir Amazon VPC\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/data-api-vpc-endpoint-subnets.png)
Untuk membuat titik akhir Amazon VPC, tentukan rentang alamat IP pribadi yang dapat mengakses titik akhir. Untuk melakukannya, pilih subnet untuk setiap Zona Ketersediaan. Hal tersebut membatasi titik akhir VPC ke rentang alamat IP pribadi khusus untuk setiap Zona Ketersediaan dan membuat titik akhir Amazon VPC di setiap Zona Ketersediaan.
1. Untuk **Aktifkan nama DNS**, pilih **Aktifkan untuk titik akhir ini**.
![\[Mengaktifkan nama DNS untuk titik akhir Amazon VPC\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/data-api-vpc-endpoint-enable-endpoint.png)
DNS Pribadi menyelesaikan nama host DNS API Data standar (`https://rds-data.region.amazonaws.com`) ke alamat IP pribadi yang dikaitkan dengan nama host DNS khusus untuk titik akhir Amazon VPC Anda. Akibatnya, Anda dapat mengakses titik akhir VPC API Data menggunakan AWS CLI atau AWS SDKs tanpa membuat perubahan kode atau konfigurasi apa pun untuk memperbarui URL titik akhir Data API.
1. Untuk **Grup keamanan**, pilih satu grup keamanan untuk dikaitkan dengan titik akhir Amazon VPC.
Pilih grup keamanan yang memungkinkan akses ke AWS layanan yang menjalankan aplikasi Anda. Misalnya, jika instans Amazon EC2 menjalankan aplikasi Anda, pilih grup keamanan yang mengizinkan akses ke instans Amazon EC2. Grup keamanan memungkinkan Anda mengontrol lalu lintas ke titik akhir Amazon VPC dari sumber daya di VPC Anda.
1. Untuk **Kebijakan**, pilih **Akses Penuh** untuk mengizinkan siapa pun di dalam Amazon VPC mengakses API Data melalui titik akhir ini. Atau, pilih **Kustom** untuk menentukan kebijakan yang membatasi akses.
Jika Anda memilih **Kustom**, masukkan kebijakan di alat pembuatan kebijakan.
1. Pilih **Create endpoint**.
Setelah titik akhir dibuat, pilih tautan di Konsol Manajemen AWS untuk melihat detail titik akhir.
![\[Tautkan ke detail titik akhir Amazon VPC\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/data-api-vpc-endpoint-link-to-details.png)
Tab **Detail** titik akhir menunjukkan nama host DNS yang dibuat saat membuat titik akhir Amazon VPC.
![\[Menautkan ke detail titik akhir Amazon VPC\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/data-api-vpc-endpoint-dns-names.png)
Anda dapat menggunakan titik akhir standar (`rds-data.region.amazonaws.com`) atau salah satu titik akhir khusus VPC untuk memanggil API Data dalam Amazon VPC. Titik akhir API Data standar secara otomatis merutekan ke titik akhir Amazon VPC. Perutean ini terjadi karena nama host DNS Pribadi diaktifkan saat titik akhir Amazon VPC dibuat.
Saat Anda menggunakan titik akhir VPC Amazon dalam panggilan API Data, semua lalu lintas antara aplikasi Anda dan Data API tetap berada di Amazon VPCs yang mengandungnya. Anda dapat menggunakan titik akhir Amazon VPC untuk semua jenis panggilan API Data. Untuk informasi tentang memanggil Data API, lihat[Memanggil Amazon RDS Data API](data-api.calling.md).
# Memanggil Amazon RDS Data API
Dengan Amazon RDS Data API (Data API) diaktifkan pada cluster Aurora DB Anda, Anda dapat menjalankan pernyataan SQL pada cluster Aurora DB dengan menggunakan Data API atau file. AWS CLI Data API mendukung bahasa pemrograman yang didukung oleh AWS SDKs. Untuk informasi selengkapnya, lihat [Alat untuk dibangun AWS](https://aws.amazon.com/tools/).
**Topics**
+ [Referensi operasi Amazon RDS Data API](data-api-operations.md)
+ [Memanggil API Data Amazon RDS dengan AWS CLI](data-api.calling.cli.md)
+ [Memanggil Amazon RDS Data API dari aplikasi Python](data-api.calling.python.md)
+ [Memanggil Amazon RDS Data API dari aplikasi Java](data-api.calling.java.md)
+ [Mengontrol perilaku batas waktu API Data](data-api-timeouts.md)
# Referensi operasi Amazon RDS Data API
Amazon RDS Data API menyediakan operasi berikut untuk melakukan pernyataan SQL.
****
| Operasi API Data | AWS CLI perintah | Deskripsi |
| --- | --- | --- |
| [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) | Menjalankan pernyataan SQL pada basis data. |
| [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) | Menjalankan pernyataan SQL batch pada array data untuk pembaruan massal dan operasi penyisipan. Anda dapat menjalankan pernyataan bahasa manipulasi data (DML) dengan array set parameter. Pernyataan SQL batch dapat memberikan peningkatan performa yang signifikan atas pernyataan penyisipan dan pembaruan individu. |
Anda dapat menggunakan operasi mana pun untuk menjalankan pernyataan SQL individual atau untuk menjalankan transaksi. Untuk transaksi, Data API menyediakan operasi berikut.
****
| Operasi API Data | AWS CLI perintah | Deskripsi |
| --- | --- | --- |
| [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) | Memulai transaksi SQL. |
| [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) | Mengakhiri transaksi SQL dan menerapkan perubahan. |
| [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) | Melakukan pembatalan transaksi. |
Operasi untuk melakukan pernyataan SQL dan transaksi pendukung memiliki parameter dan AWS CLI opsi API Data umum berikut. Beberapa operasi mendukung parameter atau opsi lain.
****
| Parameter operasi API Data | AWS CLI opsi perintah | Diperlukan | Deskripsi |
| --- | --- | --- | --- |
| `resourceArn` | `--resource-arn` | Ya | Nama Sumber Daya Amazon (ARN) dari cluster Aurora DB. Cluster harus Akun AWS sama dengan peran IAM atau pengguna yang memanggil API Data. Untuk mengakses klaster di akun yang berbeda, ambil peran dalam akun itu. |
| `secretArn` | `--secret-arn` | Ya | Nama atau ARN rahasia yang memungkinkan akses ke klaster basis data. |
RDS Data API mendukung tipe data berikut untuk 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)`
RDS Data API mendukung jenis skalar Aurora PostgreSQL berikut:
+ `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`
RDS Data API mendukung tipe array Aurora PostgreSQL berikut:
+ `BOOL[]`, `BIT[]`
+ `DATE[]`
+ `DECIMAL[]`, `NUMERIC[]`
+ `FLOAT8[]`, `DOUBLE PRECISION[]`
+ `INT[]`, `INT4[]`
+ `INT2[]`
+ `INT8[]`, `BIGINT[]`
+ `JSON[]`
+ `REAL[]`, `FLOAT[]`
+ `TEXT[]`, `CHAR(N)[]`, `VARCHAR[]`, `NAME[]`
+ `TIME[]`
+ `TIMESTAMP[]`
+ `UUID[]`
Anda dapat menggunakan parameter dalam panggilan Data API ke `ExecuteStatement` dan`BatchExecuteStatement`, dan ketika Anda menjalankan AWS CLI perintah `execute-statement` dan`batch-execute-statement`. Untuk menggunakan parameter, tentukan pasangan nama-nilai di tipe data `SqlParameter`. Tentukan nilai dengan tipe data `Field`. Tabel berikut memetakan tipe data Java Database Connectivity (JDBC) ke tipe data yang Anda tentukan dalam panggilan API Data.
****
| Tipe data JDBC | Tipe data API Data |
| --- | --- |
| `INTEGER, TINYINT, SMALLINT, BIGINT` | `LONG` (atau `STRING`) |
| `FLOAT, REAL, DOUBLE` | `DOUBLE` |
| `DECIMAL` | `STRING` |
| `BOOLEAN, BIT` | `BOOLEAN` |
| `BLOB, BINARY, LONGVARBINARY, VARBINARY` | `BLOB` |
| `CLOB` | `STRING` |
| Tipe lainnya (termasuk tipe terkait tanggal dan waktu) | `STRING` |
**catatan**
Anda dapat menentukan tipe data `LONG` atau `STRING` dalam panggilan API Data Anda untuk nilai `LONG` yang dihasilkan oleh basis data. Kami menyarankan Anda melakukannya untuk menghindari kehilangan presisi untuk jumlah yang sangat besar, yang dapat terjadi ketika Anda bekerja dengan JavaScript.
Tipe tertentu, seperti `DECIMAL` dan`TIME`, memerlukan petunjuk agar Data API meneruskan `String` nilai ke database sebagai tipe yang benar. Untuk menggunakan petunjuk, sertakan nilai untuk `typeHint` di tipe data `SqlParameter`. Berikut adalah nilai-nilai yang mungkin untuk `typeHint`:
+ `DATE` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `DATE` ke basis data. Format yang diterima adalah `YYYY-MM-DD`.
+ `DECIMAL` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `DECIMAL` ke basis data.
+ `JSON` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `JSON` ke basis data.
+ `TIME` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `TIME` ke basis data. Format yang diterima adalah `HH:MM:SS[.FFF]`.
+ `TIMESTAMP` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `TIMESTAMP` ke basis data. Format yang diterima adalah `YYYY-MM-DD HH:MM:SS[.FFF]`.
+ `UUID` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `UUID` ke basis data.
**catatan**
Saat ini, Data API tidak mendukung array Universal Unique Identifiers ()UUIDs.
**catatan**
Untuk Amazon Aurora PostgreSQL, Data API selalu menampilkan tipe data Aurora PostgreSQL di zona waktu UTC. `TIMESTAMPTZ`
# Memanggil API Data Amazon RDS dengan AWS CLI
Anda dapat memanggil RDS Data API (Data API) menggunakan file. AWS CLI
Contoh berikut menggunakan AWS CLI for Data API. Lihat informasi selengkapnya di [Referensi AWS CLI untuk API Data](https://docs.aws.amazon.com/cli/latest/reference/rds-data/index.html).
Dalam setiap contoh, ganti Amazon Resource Name (ARN) untuk cluster DB dengan ARN untuk cluster Aurora DB Anda. Selain itu, ganti ARN rahasia dengan ARN rahasia di Secrets Manager yang mengizinkan akses ke klaster basis data.
**catatan**
Kaleng AWS CLI memformat tanggapan di JSON.
**Topics**
+ [Memulai transaksi SQL](#data-api.calling.cli.begin-transaction)
+ [Menjalankan pernyataan SQL](#data-api.calling.cli.execute-statement)
+ [Menjalankan pernyataan SQL batch pada array data](#data-api.calling.cli.batch-execute-statement)
+ [Menerapkan transaksi SQL](#data-api.calling.cli.commit-transaction)
+ [Membatalkan transaksi SQL](#data-api.calling.cli.rollback-transaction)
## Memulai transaksi SQL
Anda dapat memulai transaksi SQL menggunakan perintah CLI `aws rds-data begin-transaction`. Panggilan ini menghasilkan pengidentifikasi transaksi.
**penting**
Dalam Data API, transaksi akan habis jika tidak ada panggilan yang menggunakan ID transaksinya dalam tiga menit. Jika waktu transaksi habis sebelum dilakukan, Data API akan mengembalikannya secara otomatis.
Pernyataan bahasa definisi data MySQL (DDL) di dalam transaksi menyebabkan komit implisit. Kami menyarankan Anda menjalankan setiap pernyataan MySQL DDL dalam perintah `execute-statement` terpisah dengan opsi. `--continue-after-timeout`
Selain opsi umum, tentukan opsi `--database` yang menyediakan nama basis data.
Misalnya, perintah CLI berikut memulai transaksi SQL.
Untuk Linux, macOS, atau 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"
```
Untuk 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"
```
Berikut adalah contoh respons tersebut.
```
{
"transactionId": "ABC1234567890xyz"
}
```
## Menjalankan pernyataan SQL
Anda dapat menjalankan pernyataan SQL menggunakan perintah CLI `aws rds-data execute-statement`.
Anda dapat menjalankan pernyataan SQL dalam transaksi dengan menentukan pengidentifikasi transaksi dengan opsi `--transaction-id`. Anda dapat memulai transaksi menggunakan perintah CLI `aws rds-data begin-transaction`. Anda dapat mengakhiri dan menerapkan transaksi menggunakan perintah CLI `aws rds-data commit-transaction`.
**penting**
Jika Anda tidak menentukan opsi `--transaction-id`, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Selain opsi umum, tentukan opsi-opsi berikut:
+ `--sql` (wajib) – Pernyataan SQL untuk dijalankan pada klaster basis data.
+ `--transaction-id` (opsional) – Pengidentifikasi transaksi yang dimulai menggunakan perintah CLI `begin-transaction`. Tentukan ID transaksi yang ingin Anda sertakan pernyataan SQL-nya.
+ `--parameters` (opsional) – Parameter untuk pernyataan SQL.
+ `--include-result-metadata | --no-include-result-metadata` (opsional) – Nilai yang menunjukkan apakah metadata disertakan dalam hasil. Nilai default-nya `--no-include-result-metadata`.
+ `--database` (opsional) – Nama basis data.
Opsi `--database` mungkin tidak berfungsi ketika Anda menjalankan pernyataan SQL setelah menjalankan `--sql "use database_name;"` di permintaan sebelumnya. Kami merekomendasikan agar Anda menggunakan `--database` opsi, bukan menjalankan pernyataan `--sql "use database_name;"`.
+ `--continue-after-timeout | --no-continue-after-timeout`(opsional) — Nilai yang menunjukkan apakah akan terus menjalankan pernyataan setelah panggilan melebihi interval batas waktu API Data 45 detik. Nilai default-nya `--no-continue-after-timeout`.
Untuk pernyataan bahasa definisi data (DDL), kami merekomendasikan agar Anda terus menjalankan pernyataan setelah waktu panggilan habis untuk menghindari kesalahan dan kemungkinan struktur data rusak.
+ `--format-records-as "JSON"|"NONE"` – Nilai opsional yang menentukan apakah hasil yang ditetapkan akan diformat sebagai string JSON. Nilai default-nya `"NONE"`. Lihat informasi penggunaan tentang pemrosesan set hasil JSON di [Memproses hasil kueri Amazon RDS Data API dalam format JSON](data-api-json.md).
Klaster basis data menghasilkan respons untuk panggilan.
**catatan**
Batas ukuran respons adalah 1 MiB. Jika panggilan menghasilkan data respons dengan ukuran lebih dari 1 MiB, panggilan tersebut akan diakhiri.
UntukAurora Serverless v1, jumlah maksimum permintaan per detik adalah 1.000. Untuk semua database lain yang didukung, tidak ada batasan.
Misalnya, perintah CLI berikut menjalankan satu pernyataan SQL dan menghilangkan metadata dalam hasil (default).
Untuk Linux, macOS, atau 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"
```
Untuk 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"
```
Berikut adalah contoh respons tersebut.
```
{
"numberOfRecordsUpdated": 0,
"records": [
[
{
"longValue": 1
},
{
"stringValue": "ValueOne"
}
],
[
{
"longValue": 2
},
{
"stringValue": "ValueTwo"
}
],
[
{
"longValue": 3
},
{
"stringValue": "ValueThree"
}
]
]
}
```
Perintah CLI berikut menjalankan satu pernyataan SQL dalam transaksi dengan menentukan opsi `--transaction-id`.
Untuk Linux, macOS, atau 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"
```
Untuk 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"
```
Berikut adalah contoh respons tersebut.
```
{
"numberOfRecordsUpdated": 1
}
```
Perintah CLI berikut menjalankan satu pernyataan SQL dengan parameter.
Untuk Linux, macOS, atau 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\"}}]"
```
Untuk 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\"}}]"
```
Berikut adalah contoh respons tersebut.
```
{
"numberOfRecordsUpdated": 1
}
```
Perintah CLI berikut menjalankan pernyataan SQL bahasa definisi data (DDL). Pernyataan DDL mengganti nama kolom `job` menjadi kolom `role`.
**penting**
Untuk pernyataan DDL, kami merekomendasikan agar Anda terus menjalankan pernyataan tersebut setelah waktu panggilan habis. Ketika pernyataan DDL berakhir sebelum selesai dijalankan, itu dapat mengakibatkan kesalahan dan kemungkinan struktur data rusak. Untuk terus menjalankan pernyataan setelah panggilan melebihi interval batas waktu API Data RDS 45 detik, tentukan opsi. `--continue-after-timeout`
Untuk Linux, macOS, atau 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
```
Untuk 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
```
Berikut adalah contoh respons tersebut.
```
{
"generatedFields": [],
"numberOfRecordsUpdated": 0
}
```
**catatan**
Data `generatedFields` tidak didukung oleh Aurora PostgreSQL. Untuk mendapatkan nilai-nilai bidang yang dihasilkan, gunakan klausa `RETURNING`. Lihat informasi selengkapnya di [Returning data from modified rows](https://www.postgresql.org/docs/10/dml-returning.html) dalam dokumentasi PostgreSQL.
## Menjalankan pernyataan SQL batch pada array data
Anda dapat menjalankan pernyataan SQL batch pada array data dengan menggunakan perintah CLI `aws rds-data batch-execute-statement`. Anda dapat menggunakan perintah ini untuk melakukan impor massal atau operasi pembaruan.
Anda dapat menjalankan pernyataan SQL dalam transaksi dengan menentukan pengidentifikasi transaksi dengan opsi `--transaction-id`. Anda dapat memulai transaksi menggunakan perintah CLI `aws rds-data begin-transaction`. Anda dapat mengakhiri dan menerapkan transaksi menggunakan perintah CLI `aws rds-data commit-transaction`.
**penting**
Jika Anda tidak menentukan opsi `--transaction-id`, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Selain opsi umum, tentukan opsi-opsi berikut:
+ `--sql` (wajib) – Pernyataan SQL untuk dijalankan pada klaster basis data.
**Tip**
Untuk pernyataan yang kompatibel dengan MySQL, jangan sertakan titik koma di akhir parameter `--sql`. Titik koma di belakang dapat menyebabkan kesalahan sintaksis.
+ `--transaction-id` (opsional) – Pengidentifikasi transaksi yang dimulai menggunakan perintah CLI `begin-transaction`. Tentukan ID transaksi yang ingin Anda sertakan pernyataan SQL-nya.
+ `--parameter-set` (opsional) – Set parameter untuk operasi batch.
+ `--database` (opsional) – Nama basis data.
Klaster basis data menghasilkan respons untuk panggilan.
**catatan**
Tidak ada batas atas tetap pada jumlah set parameter. Namun, ukuran maksimum permintaan HTTP yang dikirimkan melalui Data API adalah 4 MiB. Jika permintaan melebihi batas ini, Data API mengembalikan kesalahan dan tidak memproses permintaan. Batas 4 MiB ini mencakup ukuran header HTTP dan notasi JSON dalam permintaan. Dengan demikian, jumlah set parameter yang dapat Anda sertakan tergantung pada kombinasi faktor, seperti ukuran pernyataan SQL dan ukuran setiap set parameter.
Batas ukuran respons adalah 1 MiB. Jika panggilan menghasilkan data respons dengan ukuran lebih dari 1 MiB, panggilan tersebut akan diakhiri.
UntukAurora Serverless v1, jumlah maksimum permintaan per detik adalah 1.000. Untuk semua database lain yang didukung, tidak ada batasan.
Misalnya, perintah CLI berikut menjalankan pernyataan SQL batch pada array data dengan satu set parameter.
Untuk Linux, macOS, atau 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\"}}]]"
```
Untuk 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\"}}]]"
```
**catatan**
Jangan sertakan jeda baris di opsi `--parameter-sets`.
## Menerapkan transaksi SQL
Dengan menggunakan perintah CLI `aws rds-data commit-transaction`, Anda dapat mengakhiri transaksi SQL yang Anda mulai dengan `aws rds-data begin-transaction` dan menerapkan perubahan.
Selain opsi umum, tentukan opsi-opsi berikut:
+ `--transaction-id` (wajib) – Pengidentifikasi transaksi yang dimulai menggunakan perintah CLI `begin-transaction`. Tentukan ID transaksi yang ingin Anda akhiri dan terapkan.
Misalnya, perintah CLI berikut mengakhiri transaksi SQL dan menerapkan perubahan.
Untuk Linux, macOS, atau 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"
```
Untuk 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"
```
Berikut adalah contoh respons tersebut.
```
{
"transactionStatus": "Transaction Committed"
}
```
## Membatalkan transaksi SQL
Dengan menggunakan perintah CLI `aws rds-data rollback-transaction`, Anda dapat membatalkan transaksi SQL yang Anda mulai dengan `aws rds-data begin-transaction`. Membatalkan transaksi akan membatalkan perubahannya.
**penting**
Jika ID transaksi telah kedaluwarsa, transaksi dibatalkan secara otomatis. Dalam kasus ini, perintah `aws rds-data rollback-transaction` yang menentukan ID transaksi yang kedaluwarsa akan menghasilkan kesalahan.
Selain opsi umum, tentukan opsi-opsi berikut:
+ `--transaction-id` (wajib) – Pengidentifikasi transaksi yang dimulai menggunakan perintah CLI `begin-transaction`. Tentukan ID transaksi yang ingin Anda batalkan.
Misalnya, AWS CLI perintah berikut memutar kembali transaksi SQL.
Untuk Linux, macOS, atau 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"
```
Untuk 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"
```
Berikut adalah contoh respons tersebut.
```
{
"transactionStatus": "Rollback Complete"
}
```
# Memanggil Amazon RDS Data API dari aplikasi Python
Anda dapat memanggil Amazon RDS Data API (Data API) dari aplikasi Python.
Contoh berikut menggunakan AWS SDK untuk Python (Boto). Lihat informasi selengkapnya tentang Boto, lihat [Dokumentasi AWS SDK for Python (Boto 3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html).
Dalam setiap contoh, ganti Amazon Resource Name (ARN) cluster DB dengan ARN untuk cluster Aurora DB Anda. Selain itu, ganti ARN rahasia dengan ARN rahasia di Secrets Manager yang mengizinkan akses ke klaster basis data.
**Topics**
+ [Menjalankan kueri SQL](#data-api.calling.python.run-query)
+ [Menjalankan pernyataan SQL DML](#data-api.calling.python.run-inert)
+ [Menjalankan transaksi SQL](#data-api.calling.python.run-transaction)
## Menjalankan kueri SQL
Anda dapat menjalankan pernyataan `SELECT` dan mengambil hasilnya dengan aplikasi Python.
Contoh berikut menjalankan kueri SQL.
```
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'
}
]
]
```
## Menjalankan pernyataan SQL DML
Anda dapat menjalankan pernyataan bahasa manipulasi data (DML) untuk memasukkan, memperbarui, atau menghapus data dalam basis data Anda. Anda juga dapat menggunakan parameter dalam pernyataan DML.
**penting**
Jika panggilan bukan bagian dari transaksi karena tidak menyertakan parameter `transactionID`, perubahan yang dihasilkan dari panggilan tersebut diterapkan secara otomatis.
Contoh berikut menjalankan pernyataan penyisipan SQL dan menggunakan parameter.
```
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"])
```
## Menjalankan transaksi SQL
Anda dapat memulai transaksi SQL, menjalankan satu atau beberapa pernyataan SQL, lalu menerapkan perubahan dengan aplikasi Python.
**penting**
Waktu transaksi habis jika tidak ada panggilan yang menggunakan ID transaksinya dalam tiga menit. Jika waktu transaksi habis sebelum diterapkan, transaksi akan dibatalkan secara otomatis.
Jika Anda tidak menentukan ID transaksi, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Contoh berikut menjalankan transaksi SQL yang menyisipkan baris dalam tabel.
```
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
```
**catatan**
Jika Anda menjalankan pernyataan bahasa definisi data (DDL), kami merekomendasikan agar Anda terus menjalankan pernyataan setelah waktu panggilan habis. Ketika pernyataan DDL dihentikan sebelum selesai dijalankan, hal ini dapat mengakibatkan kesalahan dan kemungkinan struktur data rusak. Untuk terus menjalankan pernyataan setelah panggilan melebihi interval batas waktu API Data RDS 45 detik, setel `continueAfterTimeout` parameter ke. `true`
# Memanggil Amazon RDS Data API dari aplikasi Java
Anda dapat memanggil Amazon RDS Data API (Data API) dari aplikasi Java.
Contoh berikut menggunakan AWS SDK for Java. Lihat informasi selengkapnya di [Panduan Developer AWS SDK untuk Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/welcome.html).
Dalam setiap contoh, ganti Amazon Resource Name (ARN) cluster DB dengan ARN untuk cluster Aurora DB Anda. Selain itu, ganti ARN rahasia dengan ARN rahasia di Secrets Manager yang mengizinkan akses ke klaster basis data.
**Topics**
+ [Menjalankan kueri SQL](#data-api.calling.java.run-query)
+ [Menjalankan transaksi SQL](#data-api.calling.java.run-transaction)
+ [Menjalankan operasi SQL batch](#data-api.calling.java.run-batch)
## Menjalankan kueri SQL
Anda dapat menjalankan pernyataan `SELECT` dan mengambil hasilnya dengan aplikasi Java.
Contoh berikut menjalankan kueri SQL.
```
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));
}
}
}
```
## Menjalankan transaksi SQL
Anda dapat memulai transaksi SQL, menjalankan satu atau beberapa pernyataan SQL, lalu menerapkan perubahan dengan aplikasi Java.
**penting**
Waktu transaksi habis jika tidak ada panggilan yang menggunakan ID transaksinya dalam tiga menit. Jika waktu transaksi habis sebelum diterapkan, transaksi akan dibatalkan secara otomatis.
Jika Anda tidak menentukan ID transaksi, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Contoh berikut menjalankan transaksi SQL.
```
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);
}
}
```
**catatan**
Jika Anda menjalankan pernyataan bahasa definisi data (DDL), kami merekomendasikan agar Anda terus menjalankan pernyataan setelah waktu panggilan habis. Ketika pernyataan DDL dihentikan sebelum selesai dijalankan, hal ini dapat mengakibatkan kesalahan dan kemungkinan struktur data rusak. Untuk terus menjalankan pernyataan setelah panggilan melebihi interval batas waktu API Data RDS 45 detik, setel `continueAfterTimeout` parameter ke. `true`
## Menjalankan operasi SQL batch
Anda dapat menjalankan operasi penyisipan dan pembaruan massal pada array data dengan aplikasi Java. Anda dapat menjalankan pernyataan DML dengan array set parameter.
**penting**
Jika Anda tidak menentukan ID transaksi, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Contoh berikut menjalankan operasi penyisipan batch.
```
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);
}
}
```
# Mengontrol perilaku batas waktu API Data
Semua panggilan ke API Data bersifat sinkron. Misalkan Anda melakukan operasi API Data yang menjalankan pernyataan SQL seperti `INSERT` atau`CREATE TABLE`. Jika panggilan Data API berhasil kembali, pemrosesan SQL selesai saat panggilan kembali.
Secara default, Data API membatalkan operasi dan mengembalikan kesalahan batas waktu jika operasi tidak selesai diproses dalam waktu 45 detik. Dalam hal ini, data tidak dimasukkan, tabel tidak dibuat, dan sebagainya.
Anda dapat menggunakan Data API untuk melakukan operasi jangka panjang yang tidak dapat diselesaikan dalam waktu 45 detik. Jika Anda berharap bahwa operasi seperti operasi massal `INSERT` atau DDL pada tabel besar membutuhkan waktu lebih dari 45 detik, Anda dapat menentukan `continueAfterTimeout` parameter untuk `ExecuteStatement` operasi tersebut. Aplikasi Anda masih menerima kesalahan batas waktu. Namun, operasi terus berjalan dan tidak dibatalkan. Sebagai contoh, lihat [Menjalankan transaksi SQL](data-api.calling.java.md#data-api.calling.java.run-transaction).
Jika AWS SDK untuk bahasa pemrograman Anda memiliki periode batas waktu sendiri untuk panggilan API atau koneksi soket HTTP, pastikan bahwa semua periode batas waktu tersebut lebih dari 45 detik. Bagi sebagian orang SDKs, periode batas waktu kurang dari 45 detik secara default. Sebaiknya setel periode batas waktu khusus SDK atau khusus klien menjadi setidaknya satu menit. Melakukannya menghindari kemungkinan bahwa aplikasi Anda menerima kesalahan batas waktu sementara operasi Data API masih berhasil diselesaikan. Dengan begitu, Anda dapat yakin apakah akan mencoba kembali operasi atau tidak.
Misalnya, SDK mengembalikan kesalahan batas waktu ke aplikasi Anda, tetapi operasi Data API masih selesai dalam interval batas waktu API Data. Dalam hal ini, mencoba kembali operasi mungkin menyisipkan data duplikat atau menghasilkan hasil yang salah. SDK mungkin mencoba ulang operasi secara otomatis, menyebabkan data yang salah tanpa tindakan apa pun dari aplikasi Anda.
Interval batas waktu sangat penting untuk SDK Java 2. Dalam SDK tersebut, batas waktu panggilan API dan batas waktu soket HTTP keduanya 30 detik secara default. Berikut adalah contoh pengaturan batas waktu tersebut ke nilai yang lebih tinggi:
```
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));
}
```
Berikut adalah contoh yang setara menggunakan klien data asinkron:
```
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));
}
```
# Menggunakan pustaka klien Java untuk RDS Data API
Anda dapat mengunduh dan menggunakan pustaka klien Java untuk RDS Data API (Data API). Pustaka klien Java ini menyediakan cara alternatif untuk menggunakan Data API. Dengan menggunakan pustaka ini, Anda dapat memetakan kelas sisi klien Anda ke permintaan dan respons Data API. Dukungan pemetaan ini dapat memudahkan integrasi dengan beberapa jenis Java tertentu, seperti `Date`, `Time`, dan `BigDecimal`.
## Mengunduh pustaka klien Java untuk API Data
Pustaka klien Java Data API adalah open source GitHub di lokasi berikut:
[ https://github.com/awslabs/rds-data-api-client-perpustakaan-java](https://github.com/awslabs/rds-data-api-client-library-java)
Anda dapat membuat pustaka secara manual dari file sumber, tetapi praktik terbaiknya adalah memanfaatkan pustaka tersebut menggunakan manajemen dependensi Apache Maven. Tambahkan dependensi berikut ke file Maven POM Anda:
Untuk versi 2.x, yang kompatibel dengan AWS SDK 2.x, gunakan yang berikut ini:
```
software.amazon.rdsdata
rds-data-api-client-library-java
2.0.0
```
Untuk versi 1.x, yang kompatibel dengan AWS SDK 1.x, gunakan yang berikut ini:
```
software.amazon.rdsdata
rds-data-api-client-library-java
1.0.8
```
## Contoh pustaka klien Java
Di bawah ini Anda dapat menemukan beberapa contoh umum penggunaan pustaka klien Java API Data. Contoh berikut mengasumsikan bahwa Anda memiliki tabel `accounts` dengan dua kolom: `accountId` dan `name`. Anda juga memiliki data transfer object (DTO) berikut.
```
public class Account {
int accountId;
String name;
// getters and setters omitted
}
```
Pustaka klien memungkinkan Anda untuk lulus DTOs sebagai parameter input. Contoh berikut menunjukkan bagaimana pelanggan DTOs dipetakan ke set parameter input.
```
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();
```
Dalam beberapa kasus, bekerja dengan nilai sederhana sebagai parameter input akan terasa lebih mudah. Anda dapat melakukannya dengan sintaksis berikut.
```
client.forSql("INSERT INTO accounts(accountId, name) VALUES(:accountId, :name)")
.withParameter("accountId", 3)
.withParameter("name", "Zhang")
.execute();
```
Berikut adalah contoh lain yang bekerja dengan nilai sederhana sebagai parameter input.
```
client.forSql("INSERT INTO accounts(accountId, name) VALUES(?, ?)", 4, "Carlos")
.execute();
```
Pustaka klien menyediakan pemetaan otomatis DTOs saat hasil dikembalikan. Contoh berikut menunjukkan bagaimana hasilnya dipetakan ke Anda DTOs.
```
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);
```
Dalam banyak kasus, kumpulan hasil basis data hanya berisi satu nilai. Untuk menyederhanakan pengambilan hasil tersebut, pustaka klien menawarkan API berikut:
```
int numberOfAccounts = client.forSql("SELECT COUNT(*) FROM accounts")
.execute()
.singleValue(Integer.class);
```
**catatan**
Fungsi `mapToList` mengonversi set hasil SQL ke dalam daftar objek yang ditentukan pengguna. Kami tidak mendukung penggunaan pernyataan `.withFormatRecordsAs(RecordsFormatType.JSON)` dalam panggilan `ExecuteStatement` untuk pustaka klien Java karena fungsinya sama. Lihat informasi yang lebih lengkap di [Memproses hasil kueri Amazon RDS Data API dalam format JSON](data-api-json.md).
# Memproses hasil kueri Amazon RDS Data API dalam format JSON
Ketika Anda memanggil operasi `ExecuteStatement`, Anda dapat memilih untuk menampilkan hasil kueri sebagai string dalam format JSON. Dengan demikian, Anda dapat menggunakan kemampuan parsing JSON bahasa pemrograman Anda untuk menafsirkan dan memformat ulang set hasil. Dengan melakukan ini, Anda dapat membantu menghindari penulisan kode tambahan untuk mengulang set hasil dan menafsirkan setiap nilai kolom.
Untuk meminta set hasil dalam format JSON, teruskan parameter `formatRecordsAs` opsional dengan nilai `JSON`. Set hasil yang diformat JSON ditampilkan di bidang `formattedRecords` struktur `ExecuteStatementResponse`.
Tindakan `BatchExecuteStatement` tidak menampilkan set hasil. Dengan demikian, opsi JSON tidak berlaku untuk tindakan itu.
Untuk menyesuaikan kunci dalam struktur hash JSON, tentukan alias kolom dalam set hasil. Anda dapat melakukannya dengan menggunakan klausa `AS` dalam daftar kolom kueri SQL Anda.
Anda dapat menggunakan kemampuan JSON untuk membuat set hasil lebih mudah dibaca dan memetakan kontennya ke kerangka kerja khusus bahasa. Karena volume set hasil berenkode ASCII lebih besar dari representasi default, Anda dapat memilih representasi default untuk kueri yang menampilkan sejumlah besar baris atau nilai kolom besar yang menghabiskan lebih banyak memori daripada yang tersedia untuk aplikasi Anda.
**Topics**
+ [Mengambil hasil kueri dalam format JSON](#data-api-json-querying)
+ [Pemetaan Tipe Data](#data-api-json-datatypes)
+ [Pemecahan Masalah](#data-api-json-troubleshooting)
+ [Contoh](#data-api-json-examples)
## Mengambil hasil kueri dalam format JSON
Untuk menerima hasil yang ditetapkan sebagai string JSON, sertakan `.withFormatRecordsAs(RecordsFormatType.JSON)` dalam `ExecuteStatement` panggilan. Nilai pengembalian kembali sebagai string JSON di bidang `formattedRecords`. Dalam kasus ini, `columnMetadata` bernilai `null`. Label kolom adalah kunci dari objek yang mewakili setiap baris. Nama kolom ini diulang untuk setiap baris dalam set hasil. Nilai kolom adalah string berkutip, nilai numerik, atau nilai khusus yang merepresentasikan `true`, `false`, atau `null`. Metadata kolom seperti batasan panjang dan tipe yang tepat untuk angka dan string tidak dipertahankan dalam respons JSON.
Jika Anda menghilangkan panggilan `.withFormatRecordsAs()` atau menentukan parameter `NONE`, set hasil ditampilkan dalam format biner menggunakan bidang `Records` dan `columnMetadata`.
## Pemetaan Tipe Data
Nilai SQL dalam set hasil dipetakan ke set tipe JSON yang lebih kecil. Nilai direpresentasikan dalam JSON sebagai string, angka, dan beberapa konstanta khusus seperti `true`, `false`, dan `null`. Anda dapat mengonversi nilai-nilai ini menjadi berbagai variabel dalam aplikasi Anda, dengan menggunakan pengetikan kuat atau lemah yang sesuai untuk bahasa pemrograman Anda.
****
| Tipe data JDBC | Tipe data JSON |
| --- | --- |
| `INTEGER`, `TINYINT`, `SMALLINT`, `BIGINT` | Angka secara default. String jika opsi `LongReturnType` diatur ke `STRING`. |
| `FLOAT`, `REAL`, `DOUBLE` | Angka |
| `DECIMAL` | String secara default. Angka jika opsi `DecimalReturnType` diatur ke `DOUBLE_OR_LONG`. |
| `STRING` | String |
| `BOOLEAN`, `BIT` | Boolean |
| `BLOB`, `BINARY`, `VARBINARY`, `LONGVARBINARY` | String dalam enkode base64. |
| `CLOB` | String |
| `ARRAY` | Array |
| `NULL` | `null` |
| Tipe lainnya (termasuk tipe terkait tanggal dan waktu) | String |
## Pemecahan Masalah
Respons JSON dibatasi hingga 10 megabyte. Jika responsnya lebih besar dari batas ini, program Anda menerima kesalahan `BadRequestException`. Dalam kasus ini, Anda dapat mengatasi kesalahan menggunakan salah satu teknik berikut:
+ Kurangi jumlah baris di set hasil. Untuk melakukannya, tambahkan klausa `LIMIT`. Anda dapat membagi set hasil besar menjadi beberapa set yang lebih kecil dengan mengirimkan beberapa kueri dengan klausa `LIMIT` dan `OFFSET`.
Jika set hasil menyertakan baris yang difilter oleh logika aplikasi, Anda dapat menghapus baris tersebut dari set hasil dengan menambahkan kondisi lainnya dalam klausa `WHERE`.
+ Kurangi jumlah kolom di set hasil. Untuk melakukannya, hapus item dari daftar pilih kueri.
+ Persingkat label kolom dengan menggunakan alias kolom dalam kueri. Setiap nama kolom diulang dalam string JSON untuk setiap baris dalam set hasil. Oleh karena itu, hasil kueri dengan nama kolom panjang dan banyak baris dapat melebihi batas ukuran. Khususnya, gunakan alias kolom untuk ekspresi rumit agar seluruh ekspresi tidak diulang dalam string JSON.
+ Meskipun Anda dapat menggunakan alias kolom dengan SQL untuk menghasilkan set hasil yang memiliki beberapa kolom dengan nama yang sama, nama kunci duplikat tidak diperbolehkan di JSON. RDS API Data menampilkan kesalahan jika Anda meminta set hasil dalam format JSON dan beberapa kolom memiliki nama yang sama. Jadi, pastikan semua label kolom memiliki nama yang unik.
## Contoh
Contoh Java berikut menunjukkan cara memanggil `ExecuteStatement` dengan respons sebagai string berformat JSON, lalu menafsirkan set hasil. Gantikan nilai yang sesuai untuk*databaseName*,*secretStoreArn*, dan *clusterArn* parameter.
Contoh Java berikut menunjukkan kueri yang menampilkan nilai numerik desimal di set hasil. Panggilan `assertThat` menguji apakah bidang respons memiliki properti yang diharapkan berdasarkan aturan untuk set hasil JSON.
Contoh ini bekerja dengan skema dan data sampel berikut:
```
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);
}
```
Nilai bidang `formattedRecords` dari program sebelumnya adalah:
```
[{"a":10.0}]
```
Bidang `Records` dan `ColumnMetadata` dalam respons keduanya bernilai null karena adanya set hasil JSON.
Contoh Java berikut menunjukkan kueri yang menampilkan nilai numerik integer di set hasil. Contoh panggilan `getFormattedRecords` untuk menampilkan hanya string berformat JSON dan mengabaikan bidang respons lain yang kosong atau bernilai null. Contoh ini melakukan deserialisasi hasil ke dalam struktur yang merepresentasikan daftar catatan. Setiap catatan memiliki bidang yang namanya sesuai dengan alias kolom dari set kumpulan. Teknik ini menyederhanakan kode yang mem-parsing set hasil. Aplikasi Anda tidak harus mengulang baris dan kolom dari set hasil dan mengonversi setiap nilai ke tipe yang sesuai.
Contoh ini bekerja dengan skema dan data sampel berikut:
```
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>() {
});
}
```
Nilai bidang `formattedRecords` dari program sebelumnya adalah:
```
[{"a":17}]
```
Untuk mengambil kolom `a` baris hasil 0, aplikasi akan merujuk ke `recordsList.get(0).a`.
Sebaliknya, contoh Java berikut menunjukkan tipe kode yang diperlukan untuk membangun struktur data yang mempertahankan set hasil ketika Anda tidak menggunakan format JSON. Dalam kasus ini, setiap baris dari set hasil berisi bidang dengan informasi tentang satu pengguna. Membangun struktur data untuk merepresentasikan set hasil membutuhkan perulangan melalui baris. Untuk setiap baris, kode mengambil nilai setiap bidang, melakukan konversi tipe yang sesuai, dan menetapkan hasilnya ke bidang yang sesuai dalam objek yang mewakili baris. Kemudian, kode menambahkan objek yang merepresentasikan setiap pengguna ke struktur data yang mewakili seluruh set hasil. Jika kueri diubah untuk menyusun ulang, menambah, atau menghapus bidang dalam set hasil, kode aplikasi juga harus diubah.
```
/* 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);
}
```
Nilai sampel berikut menunjukkan nilai bidang `formattedRecords` untuk set hasil dengan jumlah kolom, alias kolom, dan tipe data kolom yang berbeda.
Jika set hasil mencakup beberapa baris, setiap barisnya direpresentasikan sebagai objek yang merupakan elemen array. Setiap kolom dalam set hasil menjadi kunci dalam objek. Nama kolom ini diulang untuk setiap baris dalam set hasil. Oleh karena itu, untuk set hasil yang terdiri dari banyak baris dan kolom, Anda mungkin perlu menentukan alias kolom pendek agar tidak melebihi batas panjang untuk seluruh respons.
Contoh ini bekerja dengan skema dan data sampel berikut:
```
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"}]
```
Jika kolom dalam set hasil didefinisikan sebagai ekspresi, teks ekspresi menjadi kunci JSON. Oleh karena itu, praktik mudah umumnya adalah menentukan alias kolom deskriptif untuk setiap ekspresi dalam daftar pilih kueri. Misalnya, kueri berikut mencakup ekspresi seperti panggilan fungsi dan operasi aritmatika dalam daftar pilihannya.
```
select count(*), max(id), 4+7 from sample_names;
```
Ekspresi tersebut diteruskan ke set hasil JSON sebagai kunci.
```
[{"count(*)":5,"max(id)":4,"4+7":11}]
```
Menambahkan kolom `AS` dengan label deskriptif membuat kunci lebih sederhana untuk ditafsirkan dalam set hasil JSON.
```
select count(*) as rows, max(id) as largest_id, 4+7 as addition_result from sample_names;
```
Dengan kueri SQL yang direvisi, label kolom yang ditentukan oleh klausa `AS` digunakan sebagai nama kunci.
```
[{"rows":5,"largest_id":4,"addition_result":11}]
```
Nilai untuk setiap pasangan kunci-nilai dalam string JSON dapat berupa string berkutip. String dapat berisi karakter unicode. Jika string berisi urutan escape maupun karakter `"` atau `\`, karakter tersebut didahului oleh karakter escape backslash. Contoh string JSON berikut menunjukkan kemungkinan ini. Misalnya, hasil `string_with_escape_sequences` berisi karakter khusus backspace, newline, carriage return, tab, form feed, dan `\`.
```
[{"quoted_string":"hello"}]
[{"unicode_string":"邓不利多"}]
[{"string_with_escape_sequences":"\b \n \r \t \f \\ '"}]
```
Nilai untuk setiap pasangan kunci-nilai dalam string JSON juga dapat merepresentasikan angka. Angka tersebut dapat berupa bilangan bulat, nilai floating-point, nilai negatif, atau nilai yang direpresentasikan sebagai notasi eksponensial. Contoh string JSON berikut menunjukkan kemungkinan ini.
```
[{"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}]
```
Nilai Boolean dan null direpresentasikan dengan kata kunci khusus tanpa kutip `true`, `false`, dan `null`. Contoh string JSON berikut menunjukkan kemungkinan ini.
```
[{"boolean_value_1":true,"boolean_value_2":false}]
[{"unknown_value":null}]
```
Jika Anda memilih nilai tipe BLOB, hasilnya direpresentasikan dalam string JSON sebagai nilai berenkode base64. Untuk mengonversi kembali nilai ke representasi aslinya, Anda dapat menggunakan fungsi dekode yang sesuai dalam bahasa aplikasi Anda. Misalnya, Anda memanggil fungsi `Base64.getDecoder().decode()` di Java. Output sampel berikut menunjukkan hasil pemilihan nilai BLOB `hello world` dan menampilkan set hasil sebagai string JSON.
```
[{"blob_column":"aGVsbG8gd29ybGQ="}]
```
Contoh Python berikut menunjukkan cara mengakses nilai-nilai dari hasil panggilan ke fungsi `execute_statement` Python. Set hasil adalah nilai string di bidang `response['formattedRecords']`. Kode ini mengubah string JSON menjadi struktur data dengan memanggil fungsi `json.loads`. Kemudian, setiap baris dari set hasil adalah elemen daftar dalam struktur data, dan Anda dapat merujuk ke setiap bidang set hasil berdasarkan nama dalam setiap baris.
```
import json
result = json.loads(response['formattedRecords'])
print (result[0]["id"])
```
JavaScript Contoh berikut menunjukkan cara mengakses nilai-nilai dari hasil panggilan ke JavaScript `executeStatement` fungsi. Set hasil adalah nilai string di bidang `response.formattedRecords`. Kode ini mengubah string JSON menjadi struktur data dengan memanggil fungsi `JSON.parse`. Kemudian, setiap baris dari set hasil adalah elemen array dalam struktur data, dan Anda dapat merujuk ke setiap bidang set hasil berdasarkan nama dalam setiap baris.
```
```
# Memecahkan Masalah Amazon RDS Data API
Gunakan bagian berikut, berjudul dengan pesan kesalahan umum, untuk membantu memecahkan masalah yang Anda miliki dengan Amazon RDS Data API (Data API).
**Topics**
+ [Transaksi tidak ditemukan](#data-api.troubleshooting.tran-id-not-found)
+ [Paket untuk kueri terlalu besar](#data-api.troubleshooting.packet-too-large)
+ [Respons basis data melebihi batas ukuran](#data-api.troubleshooting.response-size-too-large)
+ [HttpEndpoint tidak diaktifkan untuk cluster ](#data-api.troubleshooting.http-endpoint-not-enabled)
+ [DatabaseErrorException: Transaksi masih menjalankan kueri](#data-api.troubleshooting.txn-concurrent-requests-rejected)
+ [Pengecualian hasil yang tidak didukung](#data-api.troubleshooting.unsupported-result)
+ [Multi-pernyataan tidak didukung](#data-api.troubleshooting.multi-statements)
+ [Parameter skema tidak didukung](#data-api.troubleshooting.schema-parameter)
+ [IPv6 masalah konektivitas](#data-api.troubleshooting.ipv6-connectivity)
## Transaksi tidak ditemukan
Dalam kasus ini, ID transaksi yang ditentukan dalam panggilan API Data tidak ditemukan. Penyebab masalah ini ditambahkan ke pesan kesalahan, dan merupakan salah satu dari yang berikut:
+ Transaksi mungkin kedaluwarsa.
Pastikan setiap panggilan transaksional berjalan dalam tiga menit sejak panggilan sebelumnya berjalan.
Mungkin juga ID transaksi yang ditentukan tidak dibuat oleh [BeginTransaction](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BeginTransaction.html)panggilan. Pastikan panggilan Anda memiliki ID transaksi yang valid.
+ Satu panggilan sebelumnya mengakibatkan penghentian transaksi Anda.
Transaksi telah diakhiri oleh panggilan `CommitTransaction` atau `RollbackTransaction` Anda.
+ Transaksi telah dibatalkan karena kesalahan dari panggilan sebelumnya.
Periksa apakah panggilan Anda sebelumnya telah memberikan pengecualian apa pun.
Lihat informasi tentang menjalankan transaksi di [Memanggil Amazon RDS Data API](data-api.calling.md).
## Paket untuk kueri terlalu besar
Dalam kasus ini, set hasil yang ditampilkan untuk satu baris terlalu besar. Batas ukuran API Data adalah 64 KB per baris dalam set hasil yang ditampilkan oleh basis data.
Untuk mengatasi masalah ini, pastikan setiap baris dalam set hasil berukuran 64 KB atau kurang.
## Respons basis data melebihi batas ukuran
Dalam kasus ini, ukuran set hasil yang ditampilkan oleh basis data terlalu besar. Batas API Data adalah 1 MiB per baris dalam set hasil yang ditampilkan oleh basis data.
Untuk mengatasi masalah ini, pastikan panggilan ke Data API mengembalikan 1 MiB data atau kurang. Jika Anda perlu menampilkan lebih dari 1 MiB, Anda dapat menggunakan beberapa panggilan [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html) dengan klausa `LIMIT` di kueri Anda.
Lihat informasi selengkapnya tentang klausa `LIMIT` di [SELECT syntax](https://dev.mysql.com/doc/refman/8.0/en/select.html) dalam dokumentasi MySQL.
## HttpEndpoint tidak diaktifkan untuk cluster
Periksa penyebab potensial berikut untuk masalah ini:
+ Cluster Aurora DB tidak mendukung Data API. Untuk informasi tentang jenis cluster DB yang didukung RDS Data API, lihat. [Ketersediaan wilayah dan versi untuk Amazon RDS Data API](data-api.regions.md)
+ Data API tidak diaktifkan untuk cluster Aurora DB. Untuk menggunakan Data API dengan cluster Aurora DB, Data API harus diaktifkan untuk cluster DB. Untuk informasi tentang mengaktifkan Data API, lihat[Mengaktifkan API Data Amazon RDS](data-api.enabling.md).
+ Cluster DB diganti namanya setelah Data API diaktifkan untuknya. Dalam hal ini, matikan Data API untuk cluster itu dan kemudian aktifkan lagi.
+ ARN yang Anda tentukan tidak sama persis dengan ARN klaster. Periksa apakah ARN yang ditampilkan dari sumber lain atau dibangun oleh logika program cocok dengan ARN klaster secara tepat. Misalnya, pastikan ARN yang Anda gunakan memiliki kapitalisasi huruf yang benar untuk semua karakter alfabet.
## DatabaseErrorException: Transaksi masih menjalankan kueri
Jika aplikasi Anda mengirimkan permintaan dengan ID transaksi dan transaksi tersebut saat ini sedang memproses permintaan lain, Data API mengembalikan kesalahan ini ke aplikasi Anda segera. Kondisi ini mungkin muncul jika aplikasi Anda membuat permintaan asinkron, menggunakan mekanisme seperti “janji” di Javascript.
Untuk mengatasi masalah ini, tunggu hingga permintaan sebelumnya selesai dan kemudian coba lagi permintaan tersebut. Anda dapat terus mencoba lagi sampai kesalahan tidak lagi terjadi, atau aplikasi menerima beberapa jenis kesalahan yang berbeda.
Kondisi ini dapat terjadi dengan Data API untuk Aurora Serverless v2 dan instance yang disediakan. Di Data API forAurora Serverless v1, permintaan selanjutnya untuk ID transaksi yang sama secara otomatis menunggu permintaan sebelumnya selesai. Namun, perilaku lama itu berpotensi mengalami batas waktu karena permintaan sebelumnya terlalu lama. Jika Anda mem-porting aplikasi Data API lama yang membuat permintaan bersamaan, ubah logika penanganan pengecualian Anda untuk memperhitungkan jenis kesalahan baru ini.
## Pengecualian hasil yang tidak didukung
Data API tidak mendukung semua tipe data. Kesalahan ini terjadi ketika Anda menjalankan kueri yang mengembalikan tipe data yang tidak didukung.
Untuk mengatasi masalah ini, kirimkan tipe data yang tidak didukung ke`TEXT`. Contoh:
```
SELECT custom_type::TEXT FROM my_table;
-- OR
SELECT CAST(custom_type AS TEXT) FROM my_table;
```
## Multi-pernyataan tidak didukung
Multi-pernyataan tidak didukung dalam API Data untuk Aurora Serverless v2 dan klaster yang disediakan. Mencoba mengeksekusi beberapa pernyataan dalam satu panggilan API menghasilkan kesalahan ini.
Untuk mengeksekusi beberapa pernyataan, gunakan panggilan `ExecuteStatement` API terpisah atau gunakan `BatchExecuteStatement` API untuk pemrosesan batch.
## Parameter skema tidak didukung
Aurora Serverless v1 diam-diam mengabaikan parameter skema. Namun, Aurora Serverless v2 dan klaster yang disediakan secara eksplisit menolak panggilan API yang menyertakan parameter skema.
Untuk mengatasi masalah ini, hapus parameter skema dari semua panggilan ke Data API saat Anda menggunakan Aurora Serverless v2 atau klaster yang disediakan.
## IPv6 masalah konektivitas
Jika Anda mengalami masalah saat menyambungkan ke Data API menggunakan IPv6 titik akhir, periksa penyebab potensial berikut:
+ **Jaringan tidak mendukung IPv6**: Verifikasi bahwa infrastruktur jaringan Anda mendukung IPv6 dan IPv6 perutean dikonfigurasi dengan benar.
+ **Masalah resolusi DNS**: Pastikan bahwa resolver DNS Anda dapat menyelesaikan catatan AAAA untuk titik akhir dual-stack (mis.,). `rds-data.us-east-1.api.aws`
+ **Konfigurasi grup keamanan**: Perbarui aturan grup keamanan untuk mengizinkan IPv6 lalu lintas di port 443 (HTTPS). Tambahkan aturan untuk blok IPv6 CIDR (misalnya, `::/0` untuk semua IPv6 alamat).
+ **Konfigurasi ACL Jaringan**: Pastikan jaringan ACLs mengizinkan IPv6 lalu lintas pada port yang diperlukan.
+ **Kompatibilitas pustaka klien**: Verifikasi bahwa pustaka klien HTTP IPv6 dan AWS SDKs dukungan serta konektivitas dual-stack Anda.
+ **Konfigurasi titik akhir VPC**: Jika menggunakan PrivateLink, pastikan titik akhir VPC Anda dikonfigurasi untuk mendukung IPv6 dan subnet terkait memiliki blok CIDR yang ditetapkan. IPv6
Untuk memecahkan masalah IPv6 konektivitas:
1. Uji konektivitas menggunakan titik akhir IPv4 -only (`.amazonaws.com`) untuk memverifikasi bahwa masalah tersebut spesifik untuk. IPv6
1. Gunakan alat diagnostik jaringan untuk memverifikasi IPv6 konektivitas ke titik akhir dual-stack.
1. Periksa CloudTrail log untuk kesalahan otentikasi atau otorisasi saat menggunakan IPv6 titik akhir.
1. Verifikasi bahwa aplikasi Anda dikonfigurasi dengan benar untuk menggunakan endpoint dual-stack baru. URLs
# Mencatat panggilan Amazon RDS Data API dengan AWS CloudTrail
RDS Data API (Data API) terintegrasi dengan AWS CloudTrail, layanan yang menyediakan catatan tindakan yang diambil oleh pengguna, peran, atau AWS layanan di Data API. CloudTrail menangkap semua panggilan API untuk Data API sebagai peristiwa, termasuk panggilan dari konsol Amazon RDS dan dari panggilan kode ke operasi API Data. Jika Anda membuat jejak, Anda dapat mengaktifkan pengiriman CloudTrail peristiwa secara berkelanjutan ke bucket Amazon S3, termasuk peristiwa untuk Data API. Dengan menggunakan data yang dikumpulkan oleh CloudTrail, Anda dapat menentukan banyak informasi. Informasi ini mencakup permintaan yang dibuat untuk API Data, alamat IP asal permintaan, siapa yang membuat permintaan, kapan permintaan tersebut dibuat, dan detail tambahan.
Untuk mempelajari selengkapnya CloudTrail, lihat [Panduan AWS CloudTrail Pengguna](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## Bekerja dengan informasi API Data di CloudTrail
CloudTrail diaktifkan di AWS akun Anda saat Anda membuat akun. Ketika aktivitas yang didukung (peristiwa manajemen) terjadi di Data API, aktivitas tersebut direkam dalam suatu CloudTrail peristiwa bersama dengan peristiwa AWS layanan lainnya dalam **riwayat Acara**. Anda dapat melihat, mencari, dan mengunduh acara manajemen terbaru di AWS akun Anda. Untuk informasi selengkapnya, lihat [Bekerja dengan riwayat CloudTrail Acara](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html) di *Panduan AWS CloudTrail Pengguna.*
Untuk catatan peristiwa yang sedang berlangsung di AWS akun Anda, termasuk peristiwa untuk Data API, buat jejak. *Jejak* memungkinkan CloudTrail untuk mengirimkan file log ke bucket Amazon S3. Secara default, saat Anda membuat jejak di konsol, jejak tersebut berlaku untuk semua AWS Wilayah. Jejak mencatat peristiwa dari semua AWS Wilayah di AWS partisi dan mengirimkan file log ke bucket Amazon S3 yang Anda tentukan. Selain itu, Anda dapat mengonfigurasi AWS layanan lain untuk menganalisis lebih lanjut dan menindaklanjuti data peristiwa yang dikumpulkan dalam CloudTrail log. Untuk informasi selengkapnya, lihat topik berikut di *Panduan Pengguna AWS CloudTrail *:
+ [Ikhtisar untuk membuat jejak](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail layanan dan integrasi yang didukung](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Mengonfigurasi notifikasi Amazon SNS untuk CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Menerima file CloudTrail log dari beberapa Wilayah](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) dan [Menerima file CloudTrail log dari beberapa akun](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
Semua operasi API Data dicatat oleh CloudTrail dan didokumentasikan dalam [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/Welcome.html). Misalnya, panggilan ke`BatchExecuteStatement`, `BeginTransaction``CommitTransaction`, dan `ExecuteStatement` operasi menghasilkan entri dalam file CloudTrail log.
Setiap entri peristiwa atau log berisi informasi tentang entitas yang membuat permintaan tersebut. Informasi identitas membantu Anda menentukan hal berikut:
+ Baik permintaan tersebut dibuat dengan kredensial pengguna atau root.
+ Apakah permintaan tersebut dibuat dengan kredensial keamanan sementara untuk satu peran atau pengguna gabungan.
+ Apakah permintaan itu dibuat oleh AWS layanan lain.
Untuk informasi selengkapnya, lihat [Elemen userIdentity CloudTrail ](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
## Menyertakan dan mengecualikan peristiwa API Data dari jejak AWS CloudTrail
Sebagian besar pengguna API Data mengandalkan peristiwa dalam AWS CloudTrail jejak untuk menyediakan catatan operasi API Data. Data peristiwa tidak mengungkapkan nama database, nama skema, atau pernyataan SQL dalam permintaan ke Data API. Namun, mengetahui pengguna mana yang membuat jenis panggilan terhadap cluster DB tertentu pada waktu tertentu dapat membantu mendeteksi pola akses anomali.
### Menyertakan peristiwa API Data dalam suatu AWS CloudTrail jejak
*Untuk Aurora PostgreSQL Serverless v2 dan database yang disediakan, operasi API Data berikut dicatat sebagai peristiwa data. AWS CloudTrail * [Peristiwa data](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html#logging-data-events) adalah operasi API data-plane volume tinggi yang CloudTrail tidak masuk secara default. Biaya tambahan berlaku untuk peristiwa data. Untuk informasi tentang CloudTrail harga, lihat [AWS CloudTrail Harga](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)
Anda dapat menggunakan CloudTrail konsol AWS CLI, atau operasi CloudTrail API untuk mencatat operasi API Data ini. Di CloudTrail konsol, pilih **RDS Data API - DB Cluster** untuk tipe peristiwa Data. Untuk informasi selengkapnya, lihat [Mencatat peristiwa data dengan Konsol Manajemen AWS](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html#creating-data-event-selectors-with-the-AWS-CLI) di *Panduan AWS CloudTrail Pengguna*.
Dengan menggunakan AWS CLI, jalankan `aws cloudtrail put-event-selectors` perintah untuk mencatat operasi Data API ini untuk jejak Anda. Untuk mencatat semua peristiwa Data API pada kluster DB, `AWS::RDS::DBCluster` tentukan jenis sumber daya. Contoh berikut mencatat semua peristiwa Data API pada cluster DB. Untuk informasi selengkapnya, lihat [Mencatat peristiwa data dengan AWS Command Line Interface](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail-by-using-the-aws-cli.html) di *Panduan AWS CloudTrail Pengguna*.
```
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"
]
}
]
}'
```
Anda dapat mengonfigurasi pemilih acara lanjutan untuk memfilter tambahan pada`readOnly`, `eventName,` dan `resources.ARN` bidang. Untuk informasi lebih lanjut tentang bidang ini, lihat [AdvancedFieldSelector](https://docs.aws.amazon.com/awscloudtrail/latest/APIReference/API_AdvancedFieldSelector.html).
### Mengecualikan peristiwa Data API dari AWS CloudTrail jejak (Aurora Serverless v1hanya)
UntukAurora Serverless v1, peristiwa Data API adalah peristiwa manajemen. Secara default, semua peristiwa Data API disertakan dalam AWS CloudTrail jejak. Namun, karena Data API dapat menghasilkan sejumlah besar peristiwa, Anda mungkin ingin mengecualikan peristiwa ini dari CloudTrail jejak Anda. Setelan **peristiwa Exclude Amazon RDS Data API** mengecualikan semua peristiwa Data API dari jejak. Anda tidak dapat mengecualikan peristiwa API Data tertentu.
Untuk mengecualikan peristiwa API Data dari jejak, lakukan hal berikut:
+ Di CloudTrail konsol, pilih setelan **Kecualikan peristiwa Amazon RDS Data API** saat Anda [membuat jejak](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html) atau [memperbarui jejak](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-update-a-trail-console.html).
+ Di CloudTrail API, gunakan [PutEventSelectors](https://docs.aws.amazon.com/awscloudtrail/latest/APIReference/API_PutEventSelectors.html)operasi. Jika Anda menggunakan pemilih peristiwa lanjutan, Anda dapat mengecualikan peristiwa API Data dengan menyetel `eventSource` bidang yang tidak sama dengan`rdsdata.amazonaws.com`. Jika Anda menggunakan pemilih acara dasar, Anda dapat mengecualikan peristiwa Data API dengan menyetel nilai `ExcludeManagementEventSources` atribut ke`rdsdata.amazonaws.com`. Untuk informasi selengkapnya, lihat [Mencatat peristiwa dengan 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) di *Panduan AWS CloudTrail Pengguna*.
**Awas**
Mengecualikan peristiwa Data API dari CloudTrail log dapat mengaburkan tindakan API Data. Berhati-hatilah saat memberikan `cloudtrail:PutEventSelectors` kepada pengguna utama yang diperlukan untuk melakukan operasi ini.
Anda dapat mematikan pengecualian ini kapan saja dengan mengubah pengaturan konsol atau pemilih peristiwa untuk jejak. Jejak kemudian akan mulai mencatat peristiwa API Data. Namun, jejak tidak dapat memulihkan peristiwa API Data yang terjadi sedangkan pengecualian tersebut sedang berlaku.
Saat Anda mengecualikan peristiwa Data API dengan menggunakan konsol atau API, operasi CloudTrail `PutEventSelectors` API yang dihasilkan juga dicatat di CloudTrail log Anda. Jika peristiwa Data API tidak muncul di CloudTrail log Anda, cari `PutEventSelectors` peristiwa dengan `ExcludeManagementEventSources` atribut yang disetel ke`rdsdata.amazonaws.com`.
Untuk informasi lebih lanjut, lihat [Mencatat log peristiwa manajemen untuk jejak](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-events-with-cloudtrail.html) di *Panduan Pengguna AWS CloudTrail *.
## Memahami entri file log API Data
*Trail* adalah konfigurasi yang memungkinkan pengiriman peristiwa sebagai file log ke bucket Amazon S3 yang Anda tentukan. CloudTrail file log berisi satu atau lebih entri log. *Peristiwa* mewakili permintaan tunggal dari sumber manapun dan mencakup informasi tentang tindakan yang diminta, tanggal dan waktu tindakan, parameter permintaan, dan sebagainya. CloudTrail file log bukanlah jejak tumpukan yang diurutkan dari panggilan API publik, jadi file tersebut tidak muncul dalam urutan tertentu.
**Aurora PostgreSQL Serverless v2 dan disediakan**
Contoh berikut menunjukkan entri CloudTrail log yang menunjukkan `ExecuteStatement` operasi untuk Aurora PostgreSQL Serverless v2 dan database yang disediakan. **Untuk database ini, semua peristiwa Data API adalah peristiwa data di mana sumber peristiwa adalah **rdsdataapi.amazonaws.com** dan jenis acara adalah Rds Data Service.**
```
{
"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**
Contoh berikut menunjukkan bagaimana entri CloudTrail log contoh sebelumnya muncul untuk. Aurora Serverless v1 UntukAurora Serverless v1, semua acara adalah acara manajemen di mana sumber acara adalah **rdsdata.amazonaws.com** dan jenis acaranya adalah. **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"
}
```
# Memantau kueri API Data RDS dengan Performance Insights
Jika klaster Aurora menjalankan Aurora Serverless v2 atau menyediakan instance, Anda dapat menggunakan Performance Insights dengan RDS Data API.
Untuk informasi selengkapnya tentang cara menggunakan Performance Insights dengan Aurora, lihat. [Memantau muatan DB dengan Wawasan Performa di Amazon Aurora](USER_PerfInsights.md)
## Bagaimana kueri API Data RDS direpresentasikan dalam Performance Insights
Dengan Data API, klaster Aurora Anda memproses kueri berdasarkan panggilan API Data yang Anda kirimkan dari aplikasi Anda. Data API juga melakukan beberapa pernyataan SQL sebagai bagian dari cara kerja internalnya sendiri, seperti membatalkan kueri yang melebihi ambang batas waktu. Kedua jenis operasi SQL ditampilkan dalam statistik dan grafik Performance Insights.
+ **Untuk kueri Data API yang Anda kirimkan ke cluster Aurora, bidang Host di dasbor PI ditandai **sebagai RDS** Data API.** **Untuk Aurora PostgreSQL, bidang application\$1name memiliki nilai.** `rds-data-api` Cari label ini saat Anda menganalisis pemuatan basis data menggunakan **host Top** **atau Aplikasi Teratas** sebagai dimensi.
+ **Semua kueri internal yang dijalankan Data API untuk mengelola aspek database seperti kumpulan koneksi dan batas waktu kueri dianotasi dengan awalan RDS Data API.** Contoh: `/* RDS Data API */ select * from my_table;` Mencari awalan ini ketika Anda menganalisis beban database oleh **Top SQL** sebagai dimensi. pernyataan dianotasi dengan komentar SQL dari. `/* RDS Data API */`