Amazon Redshift tidak akan lagi mendukung pembuatan Python UDFs baru mulai Patch 198. Python yang ada UDFs akan terus berfungsi hingga 30 Juni 2026. Untuk informasi lebih lanjut, lihat [posting blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan API Data Amazon Redshift
Amazon Redshift Data API menyederhanakan akses ke gudang data Amazon Redshift Anda dengan menghilangkan kebutuhan untuk mengelola driver database, koneksi, konfigurasi jaringan, buffering data, kredensi, dan banyak lagi. Anda dapat menjalankan pernyataan SQL menggunakan operasi Data API dengan AWS SDK. Untuk informasi selengkapnya tentang operasi Data API, lihat Referensi [API Data Amazon Redshift](https://docs.aws.amazon.com/redshift-data/latest/APIReference/).
Data API tidak memerlukan koneksi persisten ke database Anda. 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. Panggilan ke API Data bersifat asinkron. Data API dapat menggunakan kredensil yang disimpan dalam AWS Secrets Manager atau kredenal database sementara. Anda tidak perlu meneruskan kata sandi dalam panggilan API dengan salah satu metode otorisasi. Untuk informasi lebih lanjut tentang AWS Secrets Manager, lihat [Apa itu AWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) dalam *AWS Secrets Manager User Guide*. Anda juga dapat menggunakan AWS IAM Identity Center untuk otorisasi.
Dengan API Data, Anda dapat mengakses data Amazon Redshift secara terprogram dengan aplikasi berbasis layanan web, AWS Lambda termasuk notebook Amazon AI, dan. SageMaker AWS Cloud9 Untuk informasi lebih lanjut tentang aplikasi ini, lihat [AWS Lambda](https://aws.amazon.com/lambda/), [Amazon SageMaker AI](https://aws.amazon.com/sagemaker/), dan [AWS Cloud9](https://aws.amazon.com/cloud9/).
Untuk mempelajari API Data selengkapnya, lihat [Memulai API Data Amazon Redshift](https://aws.amazon.com/blogs/big-data/get-started-with-the-amazon-redshift-data-api/) di Blog *AWS Big Data*.
## Bekerja dengan Amazon Redshift Data API
Sebelum Anda menggunakan Amazon Redshift Data API, tinjau langkah-langkah berikut:
1. Tentukan apakah Anda, sebagai pemanggil API Data, diotorisasi. Untuk informasi selengkapnya tentang otorisasi, lihat[Mengotorisasi akses ke API Data Amazon Redshift](data-api-access.md).
1. Tentukan apakah Anda berencana untuk memanggil Data API dengan kredensyal otentikasi dari Secrets Manager, kredensyal sementara, atau penggunaan. AWS IAM Identity Center Untuk informasi selengkapnya, lihat [Memilih kredensi otentikasi database saat memanggil Amazon Redshift Data API](#data-api-calling-considerations-authentication).
1. Siapkan rahasia jika Anda menggunakan Secrets Manager untuk kredensi otentikasi. Untuk informasi selengkapnya, lihat [Menyimpan kredensi database di AWS Secrets Manager](data-api-secrets.md).
1. Tinjau pertimbangan dan batasan saat memanggil Data API. Untuk informasi selengkapnya, lihat [Pertimbangan saat memanggil Amazon Redshift Data API](#data-api-calling-considerations).
1. Panggil API Data dari AWS Command Line Interface (AWS CLI), dari kode Anda sendiri, atau menggunakan editor kueri di konsol Amazon Redshift. Untuk contoh panggilan dari AWS CLI, lihat[Memanggil API Data](data-api-calling.md).
## Pertimbangan saat memanggil Amazon Redshift Data API
Pertimbangkan hal berikut saat memanggil Data API:
+ Amazon Redshift Data API dapat mengakses database di klaster yang disediakan Amazon Redshift dan grup kerja Tanpa Server Redshift. Untuk daftar Wilayah AWS tempat Redshift Data API tersedia, lihat titik akhir yang tercantum untuk [Redshift](https://docs.aws.amazon.com/general/latest/gr/redshift-service.html) Data API di. *Referensi Umum Amazon Web Services*
+ Durasi maksimum kueri adalah 24 jam.
+ Jumlah maksimum kueri aktif (`STARTED`dan `SUBMITTED` kueri) per cluster Amazon Redshift adalah 500.
+ Ukuran hasil kueri maksimum adalah 500 MB (setelah kompresi gzip). Jika panggilan mengembalikan lebih dari 500 MB data respons, panggilan akan berakhir.
+ Waktu retensi maksimum untuk hasil kueri adalah 24 jam.
+ Ukuran pernyataan kueri maksimum adalah 100 KB.
+ Data API tersedia untuk kueri cluster single-node dan multiple-node dari tipe node berikut:
+ dc2.large
+ dc2.8xlarge
+ ra3. besar
+ ra3.xlplus
+ ra3.4xlarge
+ ra3.16xlarge
+ Cluster harus berada di cloud pribadi virtual (VPC) berdasarkan layanan Amazon VPC.
+ Secara default, pengguna dengan peran IAM yang sama dengan pelari operasi `ExecuteStatement` atau `BatchExecuteStatement` API dapat bertindak berdasarkan pernyataan yang sama dengan`CancelStatement`,,, `DescribeStatement` `GetStatementResult``GetStatementResultV2`, dan operasi `ListStatements` API. Untuk bertindak pada pernyataan SQL yang sama dari pengguna lain, pengguna harus dapat mengambil peran IAM dari pengguna yang menjalankan pernyataan SQL. Untuk informasi selengkapnya tentang cara mengambil peran, lihat[Mengotorisasi akses ke API Data Amazon Redshift](data-api-access.md).
+ Pernyataan SQL dalam `Sqls` parameter operasi `BatchExecuteStatement` API dijalankan sebagai satu transaksi. Mereka berjalan secara serial dalam urutan array. Pernyataan SQL berikutnya tidak dimulai sampai pernyataan sebelumnya dalam array selesai. Jika pernyataan SQL gagal, maka karena mereka dijalankan sebagai satu transaksi, semua pekerjaan digulirkan kembali.
+ Waktu retensi maksimum untuk token klien yang digunakan dalam `ExecuteStatement` atau operasi `BatchExecuteStatement` API adalah 8 jam.
+ Jika klaster yang disediakan Amazon Redshift dan grup kerja Redshift Serverless dienkripsi menggunakan kunci yang dikelola pelanggan Redshift membuat hibah yang memungkinkan Redshift Data API menggunakan kunci untuk operasinya. Untuk informasi lebih lanjut, lihat[Menggunakan AWS KMS dengan Amazon Redshift Data API](data-api-kms.md).
+ Setiap API di Redshift Data API memiliki kuota transaksi per detik sebelum membatasi permintaan. Untuk kuota, lihat[Kuota untuk Amazon Redshift Data API](amazon-redshift-limits.md#data-api-quotas-account). Jika tingkat permintaan melebihi kuota, a `ThrottlingException` dengan Kode Status HTTP: 400 dikembalikan. Untuk merespons pelambatan, gunakan strategi coba lagi seperti yang dijelaskan dalam [Perilaku Coba lagi di Panduan Referensi](https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html) Alat *AWS SDKs dan* Alat. Strategi ini diimplementasikan secara otomatis untuk membatasi kesalahan di beberapa. AWS SDKs
**catatan**
Secara default di AWS Step Functions, percobaan ulang tidak diaktifkan. Jika Anda perlu memanggil Redshift Data API di mesin status Step Functions, sertakan parameter `ClientToken` idempotency dalam panggilan Redshift Data API Anda. Nilai `ClientToken` kebutuhan untuk bertahan di antara percobaan ulang. Dalam contoh cuplikan permintaan `ExecuteStatement` API berikut, ekspresi `States.ArrayGetItem(States.StringSplit($$.Execution.Id, ':'), 7)` menggunakan fungsi intrinsik untuk mengekstrak bagian UUID`$$.Execution.Id`, yang unik untuk setiap eksekusi mesin status. Untuk informasi selengkapnya, lihat [Fungsi intrinsik](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-intrinsic-functions.html) di Panduan *AWS Step Functions Pengembang*.
```
{
"Database": "dev",
"Sql": "select 1;",
"ClusterIdentifier": "MyCluster",
"ClientToken.$": "States.ArrayGetItem(States.StringSplit($$.Execution.Id, ':'), 7)"
}
```
## Memilih kredensi otentikasi database saat memanggil Amazon Redshift Data API
Saat memanggil Data API, Anda menggunakan salah satu metode otentikasi berikut untuk beberapa operasi API. Setiap metode membutuhkan kombinasi parameter yang berbeda.
**AWS IAM Identity Center**
Data API dapat diakses dengan satu pengguna masuk yang terdaftar di. AWS IAM Identity Center Untuk informasi tentang langkah-langkah untuk mengatur Pusat Identitas IAM, lihat[Menggunakan Data API dengan propagasi identitas tepercaya](data-api-trusted-identity-propagation.md).
**AWS Secrets Manager**
Dengan metode ini, berikan rahasia `secret-arn` yang disimpan di AWS Secrets Manager mana memiliki `username` dan`password`. Rahasia yang ditentukan berisi kredensil untuk terhubung ke yang `database` Anda tentukan. Ketika Anda menghubungkan ke cluster, Anda juga menyediakan nama database, Jika Anda memberikan identifier cluster (`dbClusterIdentifier`), itu harus cocok dengan identifier cluster yang disimpan dalam rahasia. Saat Anda menghubungkan ke workgroup tanpa server, Anda juga menyediakan nama database. Untuk informasi selengkapnya, lihat [Menyimpan kredensi database di AWS Secrets Manager](data-api-secrets.md).
Dengan metode ini, Anda juga dapat memberikan `region` nilai yang menentukan di Wilayah AWS mana data Anda berada.
**Kredensial sementara**
Dengan metode ini, pilih salah satu opsi berikut:
+ Saat menghubungkan ke workgroup tanpa server, tentukan nama workgroup dan nama database. Nama pengguna database berasal dari identitas IAM. Misalnya, `arn:iam::123456789012:user:foo` memiliki nama pengguna database`IAM:foo`. Juga, izin untuk memanggil `redshift-serverless:GetCredentials` operasi diperlukan.
+ Saat menghubungkan ke cluster sebagai identitas IAM, tentukan pengidentifikasi cluster dan nama database. Nama pengguna database berasal dari identitas IAM. Misalnya, `arn:iam::123456789012:user:foo` memiliki nama pengguna database`IAM:foo`. Juga, izin untuk memanggil `redshift:GetClusterCredentialsWithIAM` operasi diperlukan.
+ Saat menghubungkan ke cluster sebagai pengguna database, tentukan pengidentifikasi cluster, nama database, dan nama pengguna database. Juga, izin untuk memanggil `redshift:GetClusterCredentials` operasi diperlukan. Untuk informasi tentang cara bergabung dengan grup database saat menghubungkan dengan metode ini, lihat[Bergabung dengan grup basis data saat menghubungkan ke klaster](data-api-dbgroups.md).
Dengan metode ini, Anda juga dapat memberikan `region` nilai yang menentukan di Wilayah AWS mana data Anda berada.
## Memetakan tipe data JDBC saat memanggil Amazon Redshift Data API
Tabel berikut memetakan tipe data Java Database Connectivity (JDBC) ke jenis data yang Anda tentukan dalam panggilan API Data.
****
| Jenis data JDBC | Jenis data API Data |
| --- | --- |
| `INTEGER, SMALLINT, BIGINT` | `LONG` |
| `FLOAT, REAL, DOUBLE` | `DOUBLE` |
| `DECIMAL` | `STRING` |
| `BOOLEAN, BIT` | `BOOLEAN` |
| `BLOB, BINARY, LONGVARBINARY` | `BLOB` |
| `VARBINARY` | `STRING` |
| `CLOB` | `STRING` |
| Jenis lainnya (termasuk jenis yang terkait dengan tanggal dan waktu) | `STRING` |
Nilai string diteruskan ke database Amazon Redshift dan secara implisit diubah menjadi tipe data database.
**catatan**
Saat ini, Data API tidak mendukung array pengidentifikasi unik universal ()UUIDs.
## Menjalankan pernyataan SQL dengan parameter saat memanggil Amazon Redshift Data API
Anda dapat mengontrol teks SQL yang dikirimkan ke mesin database dengan memanggil operasi Data API menggunakan parameter untuk bagian dari pernyataan SQL. Parameter bernama menyediakan cara yang fleksibel untuk meneruskan parameter tanpa hardcoding mereka dalam teks SQL. Mereka membantu Anda menggunakan kembali teks SQL dan menghindari masalah injeksi SQL.
Contoh berikut menunjukkan parameter bernama dari `parameters` bidang `execute-statement` AWS CLI perintah.
```
--parameters "[{\"name\": \"id\", \"value\": \"1\"},{\"name\": \"address\", \"value\": \"Seattle\"}]"
```
Pertimbangkan hal berikut saat menggunakan parameter bernama:
+ Parameter bernama hanya dapat digunakan untuk mengganti nilai dalam pernyataan SQL.
+ Anda dapat mengganti nilai dalam pernyataan INSERT, seperti`INSERT INTO mytable VALUES(:val1)`.
Parameter bernama dapat dalam urutan apa pun dan parameter dapat digunakan lebih dari satu kali dalam teks SQL. Opsi parameter yang ditunjukkan dalam contoh sebelumnya, nilai-nilai `1` dan `Seattle` dimasukkan ke dalam kolom tabel `id` dan`address`. Dalam teks SQL, Anda menentukan parameter bernama sebagai berikut:
```
--sql "insert into mytable values (:id, :address)"
```
+ Anda dapat mengganti nilai dalam klausa kondisi, seperti`WHERE attr >= :val1`,`WHERE attr BETWEEN :val1 AND :val2`, dan`HAVING COUNT(attr) > :val`.
+ Anda tidak dapat mengganti nama kolom dalam pernyataan SQL, seperti`SELECT column-name`,`ORDER BY column-name`, atau`GROUP BY column-name`.
Misalnya, pernyataan SELECT berikut gagal dengan sintaks yang tidak valid.
```
--sql "SELECT :colname, FROM event" --parameters "[{\"name\": \"colname\", \"value\": \"eventname\"}]"
```
Jika Anda menjelaskan (`describe-statement`operasi) pernyataan dengan kesalahan sintaks, yang `QueryString` dikembalikan tidak menggantikan nama kolom untuk parameter (`"QueryString": "SELECT :colname, FROM event"`), dan kesalahan dilaporkan (ERROR: kesalahan sintaks di atau dekat\$1 "FROM\$1”\$1nPosisi: 12).
+ Anda tidak dapat mengganti nama kolom dalam fungsi agregat, seperti`COUNT(column-name)`,`AVG(column-name)`, atau`SUM(column-name)`.
+ Anda tidak dapat mengganti nama kolom dalam klausa JOIN.
+ Ketika SQL berjalan, data secara implisit dilemparkan ke tipe data. Untuk informasi selengkapnya tentang casting tipe data, lihat Tipe [data](https://docs.aws.amazon.com/redshift/latest/dg/c_Supported_data_types.html) di Panduan *Pengembang Database Amazon Redshift*.
+ Anda tidak dapat menetapkan nilai ke NULL. Data API menafsirkannya sebagai string `NULL` literal. Contoh berikut menggantikan `id` dengan string `null` literal. Bukan nilai SQL NULL.
```
--parameters "[{\"name\": \"id\", \"value\": \"null\"}]"
```
+ Anda tidak dapat menetapkan nilai panjang nol. Pernyataan Data API SQL gagal. Contoh berikut mencoba untuk mengatur `id` dengan nilai panjang nol dan menghasilkan kegagalan pernyataan SQL.
```
--parameters "[{\"name\": \"id\", \"value\": \"\"}]"
```
+ Anda tidak dapat mengatur nama tabel dalam pernyataan SQL dengan parameter. Data API mengikuti aturan JDBC`PreparedStatement`.
+ Output dari `describe-statement` operasi mengembalikan parameter query dari pernyataan SQL.
+ Hanya `execute-statement` operasi yang mendukung pernyataan SQL dengan parameter.
## Menjalankan pernyataan SQL dengan token idempotensi saat memanggil Amazon Redshift Data API
Saat Anda membuat permintaan API yang bermutasi, permintaan biasanya menampilkan hasil sebelum alur kerja asinkron operasi selesai. Operasi mungkin juga habis atau mengalami masalah server lain sebelum selesai, meskipun permintaan telah mengembalikan hasilnya. Hal ini dapat membuat sulit untuk menentukan apakah permintaan berhasil atau tidak, dan dapat menyebabkan beberapa percobaan ulang untuk memastikan bahwa operasi selesai dengan sukses. Namun, jika permintaan asli dan percobaan ulang berikutnya berhasil, operasi selesai beberapa kali. Ini berarti Anda dapat memperbarui lebih banyak sumber daya daripada yang Anda inginkan.
*Idempotency* memastikan bahwa permintaan API selesai tidak lebih dari satu kali. Dengan permintaan idempoten, jika permintaan asli berhasil diselesaikan, percobaan ulang berikutnya berhasil diselesaikan tanpa melakukan tindakan lebih lanjut. Data API `ExecuteStatement` dan `BatchExecuteStatement` operasi memiliki parameter `ClientToken` idempoten opsional. `ClientToken`Kedaluwarsa setelah 8 jam.
**penting**
Jika Anda memanggil `ExecuteStatement` dan `BatchExecuteStatement` mengoperasikannya dari AWS SDK, secara otomatis akan menghasilkan token klien untuk digunakan saat mencoba lagi. Dalam hal ini, kami tidak menyarankan menggunakan `client-token` parameter dengan `ExecuteStatement` dan `BatchExecuteStatement` operasi. Lihat CloudTrail log untuk melihat`ClientToken`. Untuk contoh CloudTrail log, lihat[Contoh API Data Amazon Redshift](logging-with-cloudtrail.md#data-api-cloudtrail).
`execute-statement` AWS CLI Perintah berikut menggambarkan `client-token` parameter opsional untuk idempotensi.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
--client-token b855dced-259b-444c-bc7b-d3e8e33f94g1
```
Tabel berikut menunjukkan beberapa tanggapan umum yang mungkin Anda dapatkan untuk permintaan API idempoten, dan memberikan rekomendasi coba ulang.
| Respons | Rekomendasi | Komentar |
| --- | --- | --- |
| 200 (OK) | Jangan coba lagi | Permintaan asli berhasil diselesaikan. Setiap percobaan ulang berikutnya berhasil kembali. |
| Kode respons 400 seri | Jangan coba lagi | Ada masalah dengan permintaan, dari antara yang berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/mgmt/data-api.html) Jika permintaan melibatkan sumber daya yang sedang dalam proses mengubah status, mencoba kembali permintaan mungkin berhasil. |
| Kode respons 500 seri | Coba lagi | Kesalahan ini disebabkan oleh masalah AWS sisi server dan umumnya bersifat sementara. Ulangi permintaan dengan strategi backoff yang sesuai. |
Untuk informasi tentang kode respons Amazon Redshift, lihat [Kesalahan Umum](https://docs.aws.amazon.com/redshift/latest/APIReference/CommonErrors.html) di Referensi API *Amazon Redshift*.
## Menjalankan pernyataan SQL dengan penggunaan kembali sesi saat memanggil Amazon Redshift Data API
Ketika Anda membuat permintaan API untuk menjalankan pernyataan SQL, sesi di mana SQL berjalan biasanya dihentikan ketika SQL selesai. Untuk menjaga sesi tetap aktif selama beberapa detik tertentu, API Data `ExecuteStatement` dan `BatchExecuteStatement` operasi memiliki `SessionKeepAliveSeconds` parameter opsional. Bidang `SessionId` respons berisi identitas sesi yang kemudian dapat digunakan dalam `BatchExecuteStatement` operasi berikutnya`ExecuteStatement`. Dalam panggilan berikutnya Anda dapat menentukan yang lain `SessionKeepAliveSeconds` untuk mengubah waktu batas waktu idle. Jika `SessionKeepAliveSeconds` tidak diubah, pengaturan batas waktu idle awal tetap ada. Pertimbangkan hal berikut saat menggunakan penggunaan kembali sesi:
+ Nilai maksimum `SessionKeepAliveSeconds` adalah 24 jam.
+ Sesi ini dapat berlangsung paling lama 24 jam. Setelah 24 jam sesi ditutup secara paksa dan kueri yang sedang berlangsung dihentikan.
+ Jumlah maksimum sesi per cluster Amazon Redshift atau grup kerja Redshift Serverless adalah 500.
+ Anda hanya dapat menjalankan satu kueri pada satu waktu dalam satu sesi. Anda harus menunggu sampai kueri selesai untuk menjalankan kueri berikutnya di sesi yang sama. Artinya, Anda tidak dapat menjalankan kueri secara paralel dalam sesi yang disediakan.
+ Data API tidak dapat mengantri kueri untuk sesi tertentu.
Untuk mengambil `SessionId` yang digunakan oleh panggilan ke `ExecuteStatement` dan `BatchExecuteStatement` operasi, panggilan `DescribeStatement` dan `ListStatements` operasi.
Contoh berikut menunjukkan penggunaan `SessionKeepAliveSeconds` dan `SessionId` parameter untuk menjaga sesi tetap hidup dan digunakan kembali. Pertama, panggil `execute-statement` AWS CLI perintah dengan `session-keep-alive-seconds` parameter opsional diatur ke`2`.
```
aws redshift-data execute-statement
--session-keep-alive-seconds 2
--sql "select 1"
--database dev
--workgroup-name mywg
```
Respons berisi pengenal sesi.
```
{
"WorkgroupName": "mywg",
"CreatedAt": 1703022996.436,
"Database": "dev",
"DbUser": "awsuser",
"Id": "07c5ffea-76d6-4786-b62c-4fe3ef529680",
"SessionId": "5a254dc6-4fc2-4203-87a8-551155432ee4"
}
```
Kemudian, panggil `execute-statement` AWS CLI perintah dengan yang `SessionId` dikembalikan dari panggilan pertama. Dan secara opsional, tentukan `session-keep-alive-seconds` parameter yang disetel `10` untuk mengubah nilai batas waktu idle.
```
aws redshift-data execute-statement
--sql "select 1"
--session-id 5a254dc6-4fc2-4203-87a8-551155432ee4
--session-keep-alive-seconds 10
```
## Mengambil hasil pernyataan SQL
Anda menggunakan operasi Data API yang berbeda untuk mengambil hasil SQL tergantung pada format hasil. Saat Anda memanggil `ExecuteStatement` dan `BatchExecuteStatement` operasi, Anda dapat menentukan apakah hasilnya diformat sebagai JSON atau CSV. Jika Anda tidak menentukan, defaultnya adalah JSON. Untuk mengambil hasil JSON, gunakan operasi. `GetStatementResult` Untuk mengambil hasil CSV, gunakan operasi. `GetStatementResultV2`
Hasil yang dikembalikan dalam format JSON adalah catatan yang menyertakan metadata tentang setiap kolom. Setiap rekaman dalam format JSON. Misalnya, respons dari `GetStatementResult` terlihat mirip dengan ini:
```
{
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "?column?",
"name": "?column?",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "",
"typeName": "int4",
"length": 0
}
],
"NextToken": "",
"Records": [
[
{
"longValue": 1
}
]
],
"TotalNumRows":
}
```
Hasil yang dikembalikan dalam format CSV adalah catatan yang menyertakan metadata tentang setiap kolom. Hasil dikembalikan dalam potongan 1 MB, di mana setiap potongan dapat menyimpan sejumlah baris dalam format CSV. Setiap permintaan mengembalikan hasil hingga 15 MB. Jika hasilnya lebih besar dari 15 MB, maka token halaman berikutnya dikembalikan untuk melanjutkan pengambilan hasilnya. Misalnya, respons dari `GetStatementResultV2` terlihat mirip dengan ini:
```
{
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "?column?",
"name": "?column?",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "?column?",
"name": "?column?",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "?column?",
"name": "?column?",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "",
"typeName": "int4",
"length": 0
}
],
"NextToken": "",
"Records": [
[
{
"CSVRecords":"1,2,3\r\n4,5,6\r\n7,8,9\rn, .... 1MB" // First 1MB Chunk
},
{
"CSVRecords":"1025,1026,1027\r\n1028,1029,1030\r\n....2MB" // Second 1MB chunk
}
...
]
],
"ResultFormat" : "CSV",
"TotalNumRows":
}
```
# Mengotorisasi akses ke API Data Amazon Redshift
Untuk mengakses Data API, pengguna harus diberi wewenang. Anda dapat mengotorisasi pengguna untuk mengakses Data API dengan menambahkan kebijakan terkelola, yang merupakan kebijakan standar AWS Identity and Access Management (IAM), ke pengguna tersebut. Sebagai praktik terbaik, kami merekomendasikan untuk melampirkan kebijakan izin ke peran IAM dan kemudian menetapkannya ke pengguna dan grup sesuai kebutuhan. Untuk informasi selengkapnya, lihat [Identitas dan manajemen akses di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-authentication-access-control.html). Untuk melihat izin yang diizinkan dan ditolak oleh kebijakan terkelola, lihat konsol IAM () [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
# Mengonfigurasi izin IAM
Amazon Redshift menyediakan kebijakan `AmazonRedshiftDataFullAccess` terkelola. Kebijakan ini menyediakan akses penuh ke operasi Amazon Redshift Data API. Kebijakan ini juga memungkinkan akses tercakup ke Amazon Redshift tertentu AWS Secrets Manager,, dan operasi IAM API yang diperlukan untuk mengautentikasi dan mengakses klaster Amazon Redshift atau grup kerja Tanpa Server Redshift.
Anda juga dapat membuat kebijakan IAM Anda sendiri yang memungkinkan akses ke sumber daya tertentu. Untuk membuat kebijakan Anda, gunakan `AmazonRedshiftDataFullAccess` kebijakan sebagai templat awal Anda. Setelah membuat kebijakan, tambahkan ke setiap pengguna yang memerlukan akses ke API Data.
Pertimbangkan persyaratan berikut dari kebijakan IAM yang terkait dengan pengguna:
+ Jika Anda menggunakan AWS Secrets Manager untuk mengautentikasi, konfirmasikan kebijakan mengizinkan penggunaan `secretsmanager:GetSecretValue` tindakan untuk mengambil rahasia yang ditandai dengan kunci. `RedshiftDataFullAccess`
+ Jika Anda menggunakan kredensi sementara untuk mengautentikasi ke kluster, konfirmasikan kebijakan tersebut mengizinkan penggunaan `redshift:GetClusterCredentials` tindakan ke nama pengguna database `redshift_data_api_user` untuk database apa pun di klaster. Nama pengguna ini harus sudah dibuat di database Anda.
+ Jika Anda menggunakan kredensi sementara untuk mengautentikasi ke grup kerja tanpa server, konfirmasikan kebijakan tersebut mengizinkan penggunaan `redshift-serverless:GetCredentials` tindakan untuk mengambil grup kerja yang diberi tag dengan kunci tersebut. `RedshiftDataFullAccess` Pengguna database dipetakan 1:1 ke identitas sumber AWS Identity and Access Management (IAM). Misalnya, pengguna sample\$1user dipetakan ke pengguna database`IAM:sample_user`, dan peran IAM sample\$1role dipetakan ke. `IAMR:sample_role` Untuk informasi selengkapnya tentang identitas IAM, lihat [Identitas IAM (pengguna, grup pengguna, dan peran)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) di Panduan Pengguna IAM.
+ Tindakan IAM `redshift-data:GetStatementResult` memungkinkan akses ke operasi keduanya `GetStatementResult` dan `GetStatementResultV2` API.
Tautan berikut memberikan informasi lebih lanjut tentang AWS Identity and Access Management *Panduan Pengguna IAM*.
+ Untuk informasi tentang membuat peran IAM, lihat [Membuat peran IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).
+ Untuk informasi tentang membuat kebijakan IAM, lihat [Membuat kebijakan IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
+ Untuk informasi tentang menambahkan kebijakan IAM ke pengguna, lihat [Menambahkan dan menghapus izin identitas IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
## Jalankan kueri pada klaster yang dimiliki oleh akun lain
Untuk menjalankan kueri pada klaster yang dimiliki oleh akun lain, akun pemilik harus menyediakan peran IAM yang dapat diasumsikan oleh API Data di akun panggilan. Misalnya, Akun B memiliki klaster yang perlu diakses oleh Akun A. Akun B dapat melampirkan kebijakan AWS terkelola `AmazonRedshiftDataFullAccess` ke peran IAM Akun B. Kemudian Akun B mempercayai Akun A menggunakan kebijakan kepercayaan seperti berikut: ``
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/someRoleA"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Terakhir, peran IAM Akun A harus dapat mengambil peran Akun B IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/someRoleB"
}
}
```
------
## Tentukan peran IAM yang membatasi sumber daya ke grup kerja Redshift Tanpa Server dan kluster Amazon Redshift di Akun AWS
Anda dapat menentukan sumber daya ARNs dalam kebijakan berbasis identitas untuk mengontrol akses ke grup kerja Redshift Tanpa Server dan klaster Amazon Redshift di file. Akun AWS Contoh ini menunjukkan cara Anda membuat kebijakan yang mengizinkan akses ke Data API hanya untuk workgroup dan cluster dalam yang ditentukan. Akun AWS
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"redshift-data:CancelStatement",
"redshift-data:DescribeStatement",
"redshift-data:GetStatementResult",
"redshift-data:ListStatements"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "redshift-data:*",
"Resource": [
"arn:aws:redshift:us-east-1:111122223333:workgroup/*",
"arn:aws:redshift:us-east-1:111122223333:cluster:*"
]
}
]
}
```
------
## Mengkonfigurasi kebijakan IAM yang membatasi akses ke informasi pernyataan SQL hanya untuk pemilik pernyataan
Secara default, Amazon Redshift Data API memperlakukan peran IAM yang digunakan saat memanggil `ExecuteStatement` dan `BatchExecuteStatement` sebagai pemilik pernyataan SQL. Siapa pun yang diizinkan untuk mengambil peran dapat mengakses informasi tentang pernyataan SQL, termasuk hasilnya. Untuk membatasi akses informasi pernyataan SQL ke sesi peran IAM dengan pemilik tertentu, tambahkan kondisi. `redshift-data:statement-owner-iam-userid: "${aws:userid}"` Kebijakan IAM berikut membatasi akses.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"redshift-data:CancelStatement",
"redshift-data:DescribeStatement",
"redshift-data:GetStatementResult",
"redshift-data:ListStatements"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"redshift-data:statement-owner-iam-userid": "${aws:userid}"
}
}
}
]
}
```
------
Anda dapat menggunakan kondisi `statement-owner-iam-userid` dengan`CancelStatement`,`DescribeStatement`,`GetStatementResult`, dan`ListStatements`. Untuk informasi selengkapnya, lihat [Tindakan yang ditentukan oleh Amazon Redshift Data API](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonredshiftdataapi.html#amazonredshiftdataapi-redshift-data_statement-owner-iam-userid).
## Konfigurasikan kebijakan IAM yang membatasi akses ke hasil SQL hanya untuk pemilik sesi
Secara default, Amazon Redshift Data API memperlakukan peran IAM yang digunakan saat memanggil `ExecuteStatement` dan `BatchExecuteStatement` sebagai pemilik sesi database yang menjalankan pernyataan SQL. Siapa pun yang diizinkan untuk mengambil peran dapat mengirimkan kueri ke sesi database. Untuk membatasi akses sesi ke sesi peran IAM dengan pemilik tertentu, tambahkan kondisi. ` redshift-data:session-owner-iam-userid: "${aws:userid}"` Kebijakan IAM berikut membatasi akses.
Kebijakan IAM berikut hanya memungkinkan pemilik sesi untuk mendapatkan hasil pernyataan. Kondisi `session-owner-iam-userid` ini digunakan untuk membatasi akses sumber daya ke yang ditentukan`userid`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"redshift-data:ExecuteStatement",
"redshift-data:BatchExecuteStatement"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"redshift-data:session-owner-iam-userid": "${aws:userid}"
}
}
}
]
}
```
------
Anda dapat menggunakan kondisi `session-owner-iam-userid` dengan `ExecuteStatement` dan`BatchExecuteStatement`. Untuk informasi selengkapnya, lihat [Tindakan yang ditentukan oleh Amazon Redshift Data API](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonredshiftdataapi.html#amazonredshiftdataapi-redshift-data_statement-owner-iam-userid).
# Menyimpan kredensi database di AWS Secrets Manager
Saat memanggil Data API, Anda dapat meneruskan kredensyal untuk klaster atau grup kerja tanpa server dengan menggunakan secret in. AWS Secrets Manager Untuk memberikan kredensial dengan cara ini, Anda menentukan nama rahasia atau Amazon Resource Name (ARN) rahasia tersebut.
Untuk menyimpan kredensil dengan Secrets Manager, Anda memerlukan izin kebijakan `SecretManagerReadWrite` terkelola. Untuk informasi selengkapnya tentang izin minimum, lihat [Membuat dan Mengelola Rahasia dengan AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/managing-secrets.html) di *Panduan AWS Secrets Manager Pengguna*.
**Untuk menyimpan kredensil Anda secara rahasia untuk cluster Amazon Redshift**
1. Gunakan AWS Secrets Manager konsol untuk membuat rahasia yang berisi kredensil untuk klaster Anda:
+ Saat Anda memilih **Simpan rahasia baru**, pilih **Credentials for Redshift cluster**.
+ Simpan nilai Anda untuk **nama Pengguna** (pengguna basis data), **Kata Sandi**, dan **cluster DB** (pengidentifikasi cluster) dalam rahasia Anda.
+ Tandai rahasia dengan kuncinya`RedshiftDataFullAccess`. Kebijakan AWS terkelola `AmazonRedshiftDataFullAccess` hanya mengizinkan tindakan `secretsmanager:GetSecretValue` untuk rahasia yang ditandai dengan kunci`RedshiftDataFullAccess`.
Untuk instruksi, lihat [Membuat Rahasia Basic](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) di *Panduan Pengguna AWS Secrets Manager *.
1. Gunakan AWS Secrets Manager konsol untuk melihat detail rahasia yang Anda buat, atau jalankan `aws secretsmanager describe-secret` AWS CLI perintah.
Catat nama dan ARN rahasia. Anda dapat menggunakan ini dalam panggilan ke Data API.
**Untuk menyimpan kredensil Anda secara rahasia untuk grup kerja tanpa server**
1. Gunakan AWS Secrets Manager AWS CLI perintah untuk menyimpan rahasia yang berisi kredensil untuk workgroup tanpa server Anda:
+ Buat rahasia Anda dalam sebuah file, misalnya file JSON bernama`mycreds.json`. Berikan nilai untuk **nama Pengguna** (pengguna database) dan **Kata Sandi** dalam file.
```
{
"username": "myusername",
"password": "mypassword"
}
```
+ Simpan nilai-nilai Anda dalam rahasia Anda dan tandai rahasia dengan kuncinya`RedshiftDataFullAccess`.
```
aws secretsmanager create-secret --name MyRedshiftSecret --tags Key="RedshiftDataFullAccess",Value="serverless" --secret-string file://mycreds.json
```
Berikut ini menunjukkan output.
```
{
"ARN": "arn:aws:secretsmanager:region:accountId:secret:MyRedshiftSecret-mvLHxf",
"Name": "MyRedshiftSecret",
"VersionId": "a1603925-e8ea-4739-9ae9-e509eEXAMPLE"
}
```
Untuk informasi selengkapnya, lihat [Membuat Rahasia Dasar dengan AWS CLI](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html#proc-create-api) di *Panduan AWS Secrets Manager Pengguna*.
1. Gunakan AWS Secrets Manager konsol untuk melihat detail rahasia yang Anda buat, atau jalankan `aws secretsmanager describe-secret` AWS CLI perintah.
Catat nama dan ARN rahasia. Anda dapat menggunakan ini dalam panggilan ke Data API.
# Membuat endpoint (AWS PrivateLink) Amazon VPC untuk API Data
Amazon Virtual Private Cloud (Amazon VPC) memungkinkan Anda meluncurkan AWS sumber daya, seperti kluster dan aplikasi Amazon Redshift, ke cloud pribadi virtual (VPC). AWS PrivateLink menyediakan konektivitas pribadi antara virtual private cloud (VPCs) dan AWS layanan dengan aman di jaringan Amazon. Dengan menggunakan AWS PrivateLink, Anda dapat membuat titik akhir VPC, yang dapat Anda gunakan sambungkan ke layanan di berbagai akun dan VPCs berdasarkan Amazon VPC. Untuk informasi selengkapnya AWS PrivateLink, lihat [Layanan Titik Akhir VPC (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-service.html) di Panduan Pengguna *Amazon Virtual Private Cloud*.
Anda dapat memanggil titik akhir API Data dengan titik akhir Amazon VPC. Dengan menggunakan titik akhir Amazon VPC, Anda akan menjaga lalu lintas antara aplikasi di Amazon VPC Anda dan API Data di jaringan AWS , 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 Amazon VPC, Anda dapat mempertahankan lalu lintas antara aplikasi yang berjalan pada instans Amazon EC2 dan API Data di VPCs yang memuatnya.
Setelah membuat titik akhir Amazon VPC, Anda dapat mulai menggunakannya tanpa membuat kode atau perubahan konfigurasi apa pun di aplikasi Anda.
**Membuat titik akhir Amazon VPC untuk API Data**
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 **redshift-data ()**. `com.amazonaws.region.redshift-data`
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.
Untuk membuat titik akhir VPC Amazon, tentukan rentang alamat IP pribadi tempat titik akhir dapat diakses. 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**.
DNS Pribadi menyelesaikan nama host DNS API Data standar (`https://redshift-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 API Data.
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. Pilih **Buat titik akhir**.
Setelah titik akhir dibuat, pilih tautan di Konsol Manajemen AWS untuk melihat detail titik akhir.
Tab **Detail** titik akhir menunjukkan nama host DNS yang dibuat saat membuat titik akhir Amazon VPC.
Anda dapat menggunakan titik akhir standar (`redshift-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 API Data tetap berada di Amazon VPCs yang mengandungnya. Anda dapat menggunakan titik akhir Amazon VPC untuk semua jenis panggilan API Data. Lihat informasi selengkapnya tentang memanggil API Data di [Pertimbangan saat memanggil Amazon Redshift Data API](data-api.md#data-api-calling-considerations).
# Bergabung dengan grup basis data saat menghubungkan ke klaster
Grup database adalah kumpulan pengguna database. Hak istimewa database dapat diberikan kepada grup. Administrator dapat mengonfigurasi peran IAM sedemikian rupa sehingga grup database ini diperhitungkan saat SQL Anda berjalan dengan API Data. Untuk informasi selengkapnya tentang grup database, lihat [Grup](https://docs.aws.amazon.com/redshift/latest/dg/r_Groups.html) di Panduan *Pengembang Database Amazon Redshift*.
Anda dapat mengonfigurasi peran IAM pemanggil API Data sehingga pengguna database yang ditentukan dalam panggilan bergabung dengan grup database saat API Data terhubung ke klaster. Kemampuan ini hanya didukung saat menghubungkan ke cluster yang disediakan. Itu tidak didukung saat menghubungkan ke grup kerja Redshift Serverless. Peran IAM dari pemanggil Data API juga harus memungkinkan tindakan. `redshift:JoinGroup`
Konfigurasikan ini dengan menambahkan tag ke peran IAM. Administrator peran IAM pemanggil menambahkan tag dengan kunci `RedshiftDbGroups` dan nilai kunci dari daftar grup database. Nilainya adalah daftar nama titik dua (:) dipisahkan dari kelompok database hingga total panjang 256 karakter. Grup database harus didefinisikan sebelumnya dalam database yang terhubung. Jika grup tertentu tidak ditemukan dalam database, itu diabaikan. Misalnya, untuk grup database `accounting` dan`retail`, nilai kunci adalah. `accounting:retail` Pasangan nilai kunci tag `{"Key":"RedshiftDbGroups","Value":"accounting:retail"}` digunakan oleh Data API untuk menentukan grup database mana yang terkait dengan pengguna database yang disediakan dalam panggilan ke Data API.
**Untuk bergabung dengan grup basis data**
1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Di panel navigasi konsol, pilih **Peran** lalu pilih nama peran yang ingin Anda edit.
1. Pilih tab **Tag**, lalu pilih **Kelola tag**.
1. Pilih **Tambah tag**, lalu tambahkan kunci **RedshiftDbGroups**dan nilai yang merupakan daftar*database-groups-colon-separated*.
1. Pilih **Simpan perubahan**.
Sekarang ketika prinsipal IAM (dengan peran IAM ini terpasang) memanggil Data API, pengguna database yang ditentukan bergabung dengan grup database yang ditentukan dalam peran IAM.
*Untuk informasi selengkapnya tentang cara melampirkan tag ke prinsipal, termasuk peran IAM dan pengguna IAM, lihat [Menandai sumber daya IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) di Panduan Pengguna IAM.*
# Menggunakan Data API dengan propagasi identitas tepercaya
Sebagai administrator akun Amazon Redshift, Anda dapat mengintegrasikan klaster atau grup kerja Amazon Redshift, yang membantu mengelola akses tenaga kerja Anda ke Amazon Redshift AWS IAM Identity Center dengan sistem masuk tunggal. Untuk informasi selengkapnya, lihat [Menyiapkan integrasi Pusat AWS Identitas IAM dengan Amazon Redshift](redshift-iam-access-control-idp-connect-console.md). Amazon Redshift Data API mendukung penyebaran identitas pengguna IAM Identity Center ke cluster atau workgroup Amazon Redshift, dan ke layanan lain, seperti, di bawah rantai. AWS Lake Formation Anda dapat mengatur dan melakukan kueri menggunakan API Data dengan mengikuti langkah-langkah dalam [AWS layanan Access secara terprogram menggunakan propagasi identitas tepercaya](https://aws.amazon.com/blogs//security/access-aws-services-programmatically-using-trusted-identity-propagation/).
Saat Anda memanggil API Data menggunakan identitas pengguna IAM Identity Center dari sesi peran IAM yang disempurnakan identitas, Anda hanya dapat mengakses pernyataan dan hasil pernyataan yang dihasilkan menggunakan pengguna Pusat Identitas IAM yang sama. Misalnya, AWS CLI perintah berikut memanggil `execute-statement` operasi untuk menjalankan perintah SQL dengan propagasi identitas tepercaya.
```
aws redshift-data execute-statement
--sql "select current_user;"
--cluster-id mycluster
--database dev
```
AWS CLI Perintah berikut memanggil `batch-execute-statement` operasi untuk menjalankan dua perintah SQL.
```
aws redshift-data batch-execute-statement
--sqls "select current_user;" "select current_date;"
--cluster-id mycluster
--database dev
```
Untuk mengakses pernyataan dengan`cancel-statement`,, `describe-statement``get-statement-result`, dan `get-statement-result-v2` dikirimkan oleh sesi peran IAM yang disempurnakan identitas, pengguna Pusat Identitas IAM dan peran IAM harus cocok dengan kredensil yang digunakan untuk menjalankan atau. `execute-statment` `batch-execute-statement` Misalnya, AWS CLI perintah berikut mendapatkan hasil dari pernyataan SQL.
```
aws redshift-data get-statement-result
--id a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
```
Untuk membuat daftar pernyataan, `workgroup-name` parameter `cluster-identifier` atau harus disediakan untuk memastikan bahwa pengguna Pusat Identitas IAM hanya memiliki akses ke aplikasi Pusat Identitas IAM Amazon Redshift tempat mereka ditugaskan. Misalnya, AWS CLI perintah berikut mencantumkan pernyataan untuk cluster tertentu.
```
aws redshift-data list-statements
--cluster-identifier mycluster
```
Anda juga dapat menjalankan operasi Data API yang mengakses objek database dalam klaster atau grup kerja menggunakan propagasi identitas tepercaya. Ini termasuk`list-databases`,`list-schemas`,`list-tables`, dan `describe-table` operasi.
Panggilan API yang dilakukan oleh pengguna IAM Identity Center dapat dilacak. AWS CloudTrail`onBehalfOf`Bagian dari CloudTrail acara menunjukkan id pengguna IAM Identity Center dan ARN toko identitas. Contoh berikut menunjukkan cuplikan CloudTrail peristiwa yang menunjukkan `onBehalfOf` bagian dengan ID pengguna IAM Identity Center `a1b2c3d4-5678-90ab-cdef-EXAMPLE11111` dan ARN penyimpanan Identitas dari. `arn:aws:identitystore::123456789012:identitystore/d-9067bc44d2`
```
{
"eventVersion":"1.10",
"userIdentity":{
"type":"AssumedRole",
...
},
"onBehalfOf":{
"userId":"a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"identityStoreArn":"arn:aws:identitystore::123456789012:identitystore/d-9067bc44d2"
}
},
"eventTime":"2025-01-13T04:46:27Z",
"eventSource":"redshift-data.amazonaws.com",
"eventName":"ExecuteStatement",
"awsRegion":"us-east-1"
}
```
Anda dapat menjalankan perintah SQL berikut untuk memeriksa kueri yang dikirimkan oleh pengguna IAM Identity Center. Dalam contoh ini, email yang terdaftar di Pusat Identitas adalah`username@example.com`.
```
SELECT
h.query_id,
h.database_name,
h.status,
h.query_text,
u.usename,
h.start_time,
h.end_time
FROM
sys_query_history h
LEFT JOIN
pg_user u
ON
h.user_id = u.usesysid
where u.usename='awsidc:username@example.com'
ORDER BY
h.start_time DESC;
```
# Memanggil API Data
Anda dapat memanggil Data API atau AWS CLI untuk menjalankan pernyataan SQL pada klaster atau grup kerja tanpa server. Operasi utama untuk menjalankan pernyataan SQL adalah [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html)dan [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html)di Referensi *API Data Amazon Redshift*. Data API mendukung bahasa pemrograman yang didukung oleh AWS SDK. Untuk informasi selengkapnya tentang ini, lihat [Alat untuk Dibangun AWS](https://aws.amazon.com/tools/).
Untuk melihat contoh kode pemanggilan Data API, lihat [Memulai dengan Redshift Data API](https://github.com/aws-samples/getting-started-with-amazon-redshift-data-api#getting-started-with-redshift-data-api) di. *GitHub* Repositori ini memiliki contoh penggunaan AWS Lambda untuk mengakses data Amazon Redshift dari Amazon EC2 AWS Glue Data Catalog,, dan Amazon Runtime. SageMaker Contoh bahasa pemrograman termasuk Python, Go, Java, dan Javascript.
Anda dapat memanggil API Data menggunakan AWS CLI.
Contoh berikut menggunakan AWS CLI untuk memanggil Data API. Untuk menjalankan contoh, edit nilai parameter agar sesuai dengan lingkungan Anda. Dalam banyak contoh, a `cluster-identifier` disediakan untuk dijalankan melawan cluster. Saat Anda menjalankan workgroup tanpa server, Anda menyediakan sebagai gantinya. `workgroup-name` Contoh-contoh ini menunjukkan beberapa operasi Data API. Untuk informasi selengkapnya, lihat* Referensi Perintah AWS AWS CLI *.
Perintah dalam contoh berikut telah dibagi dan diformat agar mudah dibaca. Tidak semua parameter dan respons ditampilkan dalam semua contoh. Untuk definisi API dari sintaks permintaan lengkap, parameter permintaan, sintaks respons, dan elemen respons, lihat [Referensi API Data Amazon Redshift](https://docs.aws.amazon.com/redshift-data/latest/APIReference/).
# Meneruskan pernyataan SQL ke gudang data Amazon Redshift
Contoh di halaman ini mencakup berbagai cara untuk meneruskan pernyataan SQL ke gudang data Anda
## Jalankan pernyataan SQL
Untuk menjalankan pernyataan SQL, gunakan `aws redshift-data execute-statement` AWS CLI perintah.
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster dan mengembalikan identifier untuk mengambil hasil. Contoh ini menggunakan metode AWS Secrets Manager otentikasi.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
```
Berikut adalah contoh respons tersebut.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster dan mengembalikan identifier untuk mengambil hasil. Contoh ini menggunakan metode otentikasi kredensial sementara.
```
aws redshift-data execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sql "select * from stl_query limit 1"
```
Berikut adalah contoh respons tersebut.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap workgroup tanpa server dan mengembalikan identifier untuk mengambil hasilnya. Contoh ini menggunakan metode otentikasi kredensial sementara.
```
aws redshift-data execute-statement
--database dev
--workgroup-name myworkgroup
--sql "select 1;"
```
Berikut adalah contoh respons tersebut.
```
{
"CreatedAt": "2022-02-11T06:25:28.748000+00:00",
"Database": "dev",
"DbUser": "IAMR:RoleName",
"Id": "89dd91f5-2d43-43d3-8461-f33aa093c41e",
"WorkgroupName": "myworkgroup"
}
```
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster dan mengembalikan identifier untuk mengambil hasil. Contoh ini menggunakan metode AWS Secrets Manager otentikasi dan token idempotensi.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
--client-token b855dced-259b-444c-bc7b-d3e8e33f94g1
```
Berikut adalah contoh respons tersebut.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
## Jalankan pernyataan SQL dengan parameter
Untuk menjalankan pernyataan SQL, gunakan `aws redshift-data execute-statement` AWS CLI perintah.
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster dan mengembalikan identifier untuk mengambil hasil. Contoh ini menggunakan metode AWS Secrets Manager otentikasi. Teks SQL memiliki parameter `distance` bernama. Dalam hal ini, jarak yang digunakan dalam predikat adalah`5`. Dalam pernyataan SELECT, parameter bernama untuk nama kolom hanya dapat digunakan dalam predikat. Nilai untuk parameter bernama untuk pernyataan SQL ditentukan dalam `parameters` opsi.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "SELECT ratecode FROM demo_table WHERE trip_distance > :distance"
--parameters "[{\"name\": \"distance\", \"value\": \"5\"}]"
--database dev
```
Berikut adalah contoh respons tersebut.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
Contoh berikut menggunakan `EVENT` tabel dari database sampel. Untuk informasi selengkapnya, lihat [tabel EVENT](https://docs.aws.amazon.com/redshift/latest/dg/r_eventtable.html) di Panduan *Pengembang Database Amazon Redshift*.
Jika Anda belum memiliki `EVENT` tabel dalam database Anda, Anda dapat membuatnya menggunakan Data API sebagai berikut:
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "create table event( eventid integer not null distkey,
venueid smallint not null,
catid smallint not null,
dateid smallint not null sortkey,
eventname varchar(200),
starttime timestamp)"
```
Perintah berikut menyisipkan satu baris ke dalam `EVENT` tabel.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:eventid, :venueid::smallint, :catid, :dateid, :eventname, :starttime)"
--parameters "[{\"name\": \"eventid\", \"value\": \"1\"}, {\"name\": \"venueid\", \"value\": \"1\"},
{\"name\": \"catid\", \"value\": \"1\"},
{\"name\": \"dateid\", \"value\": \"1\"},
{\"name\": \"eventname\", \"value\": \"event 1\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"}]"
```
Perintah berikut menyisipkan baris kedua ke dalam `EVENT` tabel. Contoh ini menunjukkan hal berikut:
+ Parameter bernama `id` digunakan empat kali dalam teks SQL.
+ Konversi tipe implisit diterapkan secara otomatis saat memasukkan parameter. `starttime`
+ `venueid`Kolom adalah tipe cast ke tipe data SMALLINT.
+ String karakter yang mewakili tipe data DATE secara implisit diubah menjadi tipe data TIMESTAMP.
+ Komentar dapat digunakan dalam teks SQL.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:id, :id::smallint, :id, :id, :eventname, :starttime) /*this is comment, and it won't apply parameterization for :id, :eventname or :starttime here*/"
--parameters "[{\"name\": \"eventname\", \"value\": \"event 2\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"},
{\"name\": \"id\", \"value\": \"2\"}]"
```
Berikut ini menunjukkan dua baris yang disisipkan:
```
eventid | venueid | catid | dateid | eventname | starttime
---------+---------+-------+--------+-----------+---------------------
1 | 1 | 1 | 1 | event 1 | 2022-02-22 00:00:00
2 | 2 | 2 | 2 | event 2 | 2022-02-22 00:00:00
```
Perintah berikut menggunakan parameter bernama dalam klausa WHERE untuk mengambil baris di mana `eventid` adalah. `1`
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "select * from event where eventid=:id"
--parameters "[{\"name\": \"id\", \"value\": \"1\"}]"
```
Jalankan perintah berikut untuk mendapatkan hasil SQL dari pernyataan SQL sebelumnya:
```
aws redshift-data get-statement-result --id 7529ad05-b905-4d71-9ec6-8b333836eb5a
```
Memberikan hasil sebagai berikut:
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"stringValue": "event 1"
},
{
"stringValue": "2022-02-22 00:00:00.0"
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "eventid",
"length": 0,
"name": "eventid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "venueid",
"length": 0,
"name": "venueid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "catid",
"length": 0,
"name": "catid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "dateid",
"length": 0,
"name": "dateid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "eventname",
"length": 0,
"name": "eventname",
"nullable": 1,
"precision": 200,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "varchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 1,
"precision": 29,
"scale": 6,
"schemaName": "public",
"tableName": "event",
"typeName": "timestamp"
}
],
"TotalNumRows": 1
}
```
## Jalankan beberapa pernyataan SQL
Untuk menjalankan beberapa pernyataan SQL dengan satu perintah, gunakan `aws redshift-data batch-execute-statement` AWS CLI perintah.
AWS CLI Perintah berikut menjalankan tiga pernyataan SQL terhadap cluster dan mengembalikan identifier untuk mengambil hasil. Contoh ini menggunakan metode otentikasi kredensial sementara.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "set timezone to BST" "select * from mytable" "select * from another_table"
```
Berikut adalah contoh respons tersebut.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
# Daftar metadata tentang pernyataan SQL
Untuk daftar metadata tentang pernyataan SQL, gunakan perintah. `aws redshift-data list-statements` AWS CLI Otorisasi untuk menjalankan perintah ini didasarkan pada izin IAM pemanggil.
AWS CLI Perintah berikut mencantumkan pernyataan SQL yang berjalan.
```
aws redshift-data list-statements
--status ALL
```
Berikut adalah contoh respons tersebut.
```
{
"Statements": [
{
"CreatedAt": 1598306924.632,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
},
{
"CreatedAt": 1598311717.437,
"Id": "e0ebd578-58b3-46cc-8e52-8163fd7e01aa",
"QueryString": "select * from stl_query limit 1",
"Status": "FAILED",
"UpdatedAt": 1598311719.008
},
{
"CreatedAt": 1598313683.65,
"Id": "c361d4f7-8c53-4343-8c45-6b2b1166330c",
"QueryString": "select * from stl_query limit 1",
"Status": "ABORTED",
"UpdatedAt": 1598313685.495
},
{
"CreatedAt": 1598306653.333,
"Id": "a512b7bd-98c7-45d5-985b-a715f3cfde7f",
"QueryString": "select 1",
"Status": "FINISHED",
"UpdatedAt": 1598306653.992
}
]
}
```
# Jelaskan metadata tentang pernyataan SQL
Untuk mendapatkan deskripsi metadata untuk pernyataan SQL, gunakan perintah. `aws redshift-data describe-statement` AWS CLI Otorisasi untuk menjalankan perintah ini didasarkan pada izin IAM pemanggil.
AWS CLI Perintah berikut menjelaskan pernyataan SQL.
```
aws redshift-data describe-statement
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
Berikut adalah contoh respons tersebut.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Duration": 1095981511,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"RedshiftPid": 20859,
"RedshiftQueryId": 48879,
"ResultRows": 1,
"ResultSize": 4489,
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
}
```
Berikut ini adalah contoh `describe-statement` respon setelah menjalankan `batch-execute-statement` perintah dengan beberapa pernyataan SQL.
```
{
"ClusterIdentifier": "mayo",
"CreatedAt": 1623979777.126,
"Duration": 6591877,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652",
"RedshiftPid": 31459,
"RedshiftQueryId": 0,
"ResultRows": 2,
"ResultSize": 22,
"Status": "FINISHED",
"SubStatements": [
{
"CreatedAt": 1623979777.274,
"Duration": 3396637,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:1",
"QueryString": "select 1;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979777.903
},
{
"CreatedAt": 1623979777.274,
"Duration": 3195240,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2",
"QueryString": "select 2;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979778.076
}
],
"UpdatedAt": 1623979778.183
}
```
# Ambil hasil dari pernyataan SQL
Untuk mengambil hasil dari pernyataan SQL yang berjalan, gunakan perintah `redshift-data get-statement-result` or `redshift-data get-statement-result-v2` AWS CLI . Hasil dari `get-statement-result` dalam format JSON. Hasil dari `get-statement-result-v2` dalam format CSV. Anda dapat memberikan `Id` yang Anda terima sebagai tanggapan terhadap `execute-statement` atau`batch-execute-statement`. `Id`Nilai untuk pernyataan SQL dijalankan oleh `batch-execute-statement` dapat diambil dalam hasil `describe-statement` dan diakhiran oleh titik dua dan nomor urut seperti. `b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2` Jika Anda menjalankan beberapa pernyataan SQL dengan`batch-execute-statement`, setiap pernyataan SQL memiliki `Id` nilai seperti yang ditunjukkan pada. `describe-statement` Otorisasi untuk menjalankan perintah ini didasarkan pada izin IAM pemanggil.
Pernyataan berikut mengembalikan hasil dari pernyataan SQL dijalankan oleh `execute-statement` yang membiarkan `ResultFormat` default untuk`JSON`. Untuk mengambil hasilnya, hubungi `get-statement-result` operasi.
```
aws redshift-data get-statement-result
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
Pernyataan berikut mengembalikan hasil dari pernyataan SQL kedua dijalankan oleh`batch-execute-statement`.
```
aws redshift-data get-statement-result
--id b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2
```
Berikut ini adalah contoh dari respon untuk panggilan ke `get-statement-result` mana hasil SQL dikembalikan dalam format JSON dalam `Records` kunci respon.
```
{
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "userid",
"length": 0,
"name": "userid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "query",
"length": 0,
"name": "query",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "label",
"length": 0,
"name": "label",
"nullable": 0,
"precision": 320,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "xid",
"length": 0,
"name": "xid",
"nullable": 0,
"precision": 19,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int8"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "pid",
"length": 0,
"name": "pid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "database",
"length": 0,
"name": "database",
"nullable": 0,
"precision": 32,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "querytxt",
"length": 0,
"name": "querytxt",
"nullable": 0,
"precision": 4000,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "endtime",
"length": 0,
"name": "endtime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"type": 93,
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "aborted",
"length": 0,
"name": "aborted",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "insert_pristine",
"length": 0,
"name": "insert_pristine",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "concurrency_scaling_status",
"length": 0,
"name": "concurrency_scaling_status",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
}
],
"Records": [
[
{
"longValue": 1
},
{
"longValue": 3
},
{
"stringValue": "health"
},
{
"longValue": 1023
},
{
"longValue": 15279
},
{
"stringValue": "dev"
},
{
"stringValue": "select system_status from stv_gui_status;"
},
{
"stringValue": "2020-08-21 17:33:51.88712"
},
{
"stringValue": "2020-08-21 17:33:52.974306"
},
{
"longValue": 0
},
{
"longValue": 0
},
{
"longValue": 6
}
]
],
"TotalNumRows": 1
}
```
Contoh berikut menunjukkan pernyataan SQL dijalankan oleh `execute-statement` untuk mengembalikan hasil sebagai JSON. Tabel `testingtable` memiliki tiga kolom integer (col1, col2, col3) dan ada tiga baris dengan nilai (1, 2, 3), (4, 5, 6), dan (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format JSON
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Berikut ini adalah contoh dari respon untuk panggilan ke `get-statement-result` mana hasil SQL dikembalikan dalam format JSON dalam `Records` kunci respon.
```
aws redshift-data get-statement-result
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 2
},
{
"longValue": 3
}
],
[
{
"longValue": 4
},
{
"longValue": 5
},
{
"longValue": 6
}
],
[
{
"longValue": 7
},
{
"longValue": 8
},
{
"longValue": 9
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3
}
```
Contoh berikut menunjukkan pernyataan SQL dijalankan oleh `execute-statement` untuk mengembalikan hasil sebagai CSV. Tabel `testingtable` memiliki tiga kolom integer (col1, col2, col3) dan ada tiga baris dengan nilai (1, 2, 3), (4, 5, 6), dan (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format CSV
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Berikut ini adalah contoh respons terhadap panggilan ke `get-statement-result-v2` tempat hasil SQL dikembalikan dalam format CSV di `Records` kunci respons. Baris dipisahkan oleh carriage return dan newline (\$1 r\$1n). Baris pertama yang dikembalikan `Records` adalah header kolom. Hasil yang dikembalikan dalam format CSV dikembalikan dalam 1 MB di mana setiap potongan dapat menyimpan sejumlah baris hingga 1MB.
```
aws redshift-data get-statement-result-v2
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
{
"CSVRecords": "col1,col2,col3\r\n1,2,3\r\n4,5,6\r\n7,8,9\r\n"
}
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3,
"ResultFormat": "csv"
}
```
# Jelaskan tabel
Untuk mendapatkan metadata yang menggambarkan tabel, gunakan perintah. `aws redshift-data describe-table` AWS CLI
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster dan mengembalikan metadata yang menggambarkan tabel. Contoh ini menggunakan metode AWS Secrets Manager otentikasi.
```
aws redshift-data describe-table
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
```
Berikut adalah contoh respons tersebut.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster yang menggambarkan tabel. Contoh ini menggunakan metode otentikasi kredensial sementara.
```
aws redshift-data describe-table
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
```
Berikut adalah contoh respons tersebut.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_supported",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_verified_by",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "comments",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
# Daftar database dalam sebuah cluster
Untuk membuat daftar database dalam sebuah cluster, gunakan `aws redshift-data list-databases` AWS CLI perintah.
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster untuk daftar database. Contoh ini menggunakan metode AWS Secrets Manager otentikasi.
```
aws redshift-data list-databases
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Berikut adalah contoh respons tersebut.
```
{
"Databases": [
"dev"
]
}
```
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster untuk daftar database. Contoh ini menggunakan metode otentikasi kredensial sementara.
```
aws redshift-data list-databases
--db-user myuser
--cluster-identifier mycluster-test
--database dev
```
Berikut adalah contoh respons tersebut.
```
{
"Databases": [
"dev"
]
}
```
# Daftar skema dalam database
Untuk membuat daftar skema dalam database, gunakan `aws redshift-data list-schemas` AWS CLI perintah.
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster untuk daftar skema dalam database. Contoh ini menggunakan metode AWS Secrets Manager otentikasi.
```
aws redshift-data list-schemas
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Berikut adalah contoh respons tersebut.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster untuk daftar skema dalam database. Contoh ini menggunakan metode otentikasi kredensial sementara.
```
aws redshift-data list-schemas
--db-user mysuser
--cluster-identifier mycluster-test
--database dev
```
Berikut adalah contoh respons tersebut.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
# Daftar tabel dalam database
Untuk membuat daftar tabel dalam database, gunakan `aws redshift-data list-tables` AWS CLI perintah.
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster untuk daftar tabel dalam database. Contoh ini menggunakan metode AWS Secrets Manager otentikasi.
```
aws redshift-data list-tables
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Berikut adalah contoh respons tersebut.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
}
```
AWS CLI Perintah berikut menjalankan pernyataan SQL terhadap cluster untuk daftar tabel dalam database. Contoh ini menggunakan metode otentikasi kredensial sementara.
```
aws redshift-data list-tables
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Berikut adalah contoh respons tersebut.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
]
}
```
# Memecahkan masalah untuk Amazon Redshift Data API
Gunakan bagian berikut, yang berjudul pesan kesalahan umum, untuk membantu memecahkan masalah yang Anda alami dengan API Data.
**Topics**
+ [Paket untuk kueri terlalu besar](#data-api-troubleshooting-packet-too-large)
+ [Respons basis data melebihi batas ukuran](#data-api-troubleshooting-response-size-too-large)
## Paket untuk kueri terlalu besar
Jika Anda melihat kesalahan yang menunjukkan bahwa paket untuk kueri terlalu besar, umumnya set hasil yang dikembalikan untuk 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
Jika Anda melihat kesalahan yang menunjukkan bahwa respons database telah melebihi batas ukuran, umumnya ukuran kumpulan hasil yang dikembalikan oleh database terlalu besar. Batas Data API adalah 500 MB dalam kumpulan hasil yang dikembalikan oleh database.
Untuk mengatasi masalah ini, pastikan panggilan ke Data API mengembalikan 500 MB data atau kurang. Jika Anda perlu mengembalikan lebih dari 500 MB, Anda dapat menjalankan beberapa panggilan pernyataan dengan `LIMIT` klausa dalam kueri Anda.
# Menjadwalkan operasi Amazon Redshift Data API dengan Amazon EventBridge
Anda dapat membuat aturan yang cocok dengan peristiwa yang dipilih dan mengarahkannya ke target untuk mengambil tindakan. Anda juga dapat menggunakan aturan untuk mengambil tindakan pada jadwal yang telah ditentukan. Untuk informasi selengkapnya, lihat [Panduan EventBridge Pengguna Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/).
Untuk menjadwalkan operasi Data API dengan EventBridge, peran IAM terkait harus mempercayai prinsipal untuk CloudWatch Acara (events.amazonaws.com). Peran ini harus setara dengan kebijakan terkelola yang `AmazonEventBridgeFullAccess` dilampirkan. Itu juga harus memiliki izin `AmazonRedshiftDataFullAccess` kebijakan yang dikelola oleh API Data. Anda dapat membuat peran IAM dengan izin ini di konsol IAM. Saat membuat peran di konsol IAM, pilih entitas terpercaya AWS layanan untuk CloudWatch Acara. Tentukan peran IAM dalam nilai `RoleArn` JSON di target. EventBridge Untuk informasi selengkapnya tentang membuat peran IAM, lihat [Membuat Peran untuk AWS Layanan (Konsol)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console) di *Panduan Pengguna IAM*.
Aturan `name` yang Anda buat di Amazon EventBridge harus cocok dengan `StatementName` di`RedshiftDataParameters`.
Contoh berikut menunjukkan variasi pembuatan EventBridge aturan dengan satu atau beberapa pernyataan SQL dan dengan cluster Amazon Redshift atau grup kerja Amazon Redshift Tanpa Server sebagai gudang data.
## Memanggil dengan satu pernyataan SQL dan cluster
Contoh berikut menggunakan AWS CLI untuk membuat EventBridge aturan yang digunakan untuk menjalankan pernyataan SQL terhadap cluster Amazon Redshift.
```
aws events put-rule
--name test-redshift-cluster-data
--schedule-expression "rate(1 minute)"
```
Kemudian EventBridge target dibuat untuk berjalan pada jadwal yang ditentukan dalam aturan.
```
aws events put-targets
--cli-input-json file://data.json
```
File input data.json adalah sebagai berikut. Kunci `Sql` JSON menunjukkan ada pernyataan SQL tunggal. Nilai `Arn` JSON berisi pengidentifikasi cluster. Nilai `RoleArn` JSON berisi peran IAM yang digunakan untuk menjalankan SQL seperti yang dijelaskan sebelumnya.
```
{
"Rule": "test-redshift-cluster-data",
"EventBusName": "default",
"Targets": [
{
"Id": "2",
"Arn": "arn:aws:redshift:us-east-1:123456789012:cluster:mycluster",
"RoleArn": "arn:aws:iam::123456789012:role/Administrator",
"RedshiftDataParameters": {
"Database": "dev",
"DbUser": "root",
"Sql": "select 1;",
"StatementName": "test-redshift-cluster-data",
"WithEvent": true
}
}
]
}
```
## Memanggil dengan satu pernyataan SQL dan workgroup
Contoh berikut menggunakan AWS CLI untuk membuat EventBridge aturan yang digunakan untuk menjalankan pernyataan SQL terhadap workgroup Amazon Redshift Tanpa Server.
```
aws events put-rule
--name test-redshift-serverless-workgroup-data
--schedule-expression "rate(1 minute)"
```
Kemudian EventBridge target dibuat untuk berjalan pada jadwal yang ditentukan dalam aturan.
```
aws events put-targets
--cli-input-json file://data.json
```
File input data.json adalah sebagai berikut. Kunci `Sql` JSON menunjukkan ada pernyataan SQL tunggal. Nilai `Arn` JSON berisi nama workgroup. Nilai `RoleArn` JSON berisi peran IAM yang digunakan untuk menjalankan SQL seperti yang dijelaskan sebelumnya.
```
{
"Rule": "test-redshift-serverless-workgroup-data",
"EventBusName": "default",
"Targets": [
{
"Id": "2",
"Arn": "arn:aws:redshift-serverless:us-east-1:123456789012:workgroup/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"RoleArn": "arn:aws:iam::123456789012:role/Administrator",
"RedshiftDataParameters": {
"Database": "dev",
"Sql": "select 1;",
"StatementName": "test-redshift-serverless-workgroup-data",
"WithEvent": true
}
}
]
}
```
## Memanggil dengan beberapa pernyataan SQL dan cluster
Contoh berikut menggunakan AWS CLI untuk membuat EventBridge aturan yang digunakan untuk menjalankan beberapa pernyataan SQL terhadap cluster Amazon Redshift.
```
aws events put-rule
--name test-redshift-cluster-data
--schedule-expression "rate(1 minute)"
```
Kemudian EventBridge target dibuat untuk berjalan pada jadwal yang ditentukan dalam aturan.
```
aws events put-targets
--cli-input-json file://data.json
```
File input data.json adalah sebagai berikut. Kunci `Sqls` JSON menunjukkan ada beberapa pernyataan SQL. Nilai `Arn` JSON berisi pengidentifikasi cluster. Nilai `RoleArn` JSON berisi peran IAM yang digunakan untuk menjalankan SQL seperti yang dijelaskan sebelumnya.
```
{
"Rule": "test-redshift-cluster-data",
"EventBusName": "default",
"Targets": [
{
"Id": "2",
"Arn": "arn:aws:redshift:us-east-1:123456789012:cluster:mycluster",
"RoleArn": "arn:aws:iam::123456789012:role/Administrator",
"RedshiftDataParameters": {
"Database": "dev",
"Sqls": ["select 1;", "select 2;", "select 3;"],
"StatementName": "test-redshift-cluster-data",
"WithEvent": true
}
}
]
}
```
## Memanggil dengan beberapa pernyataan SQL dan workgroup
Contoh berikut menggunakan AWS CLI untuk membuat EventBridge aturan yang digunakan untuk menjalankan beberapa pernyataan SQL terhadap workgroup Amazon Redshift Tanpa Server.
```
aws events put-rule
--name test-redshift-serverless-workgroup-data
--schedule-expression "rate(1 minute)"
```
Kemudian EventBridge target dibuat untuk berjalan pada jadwal yang ditentukan dalam aturan.
```
aws events put-targets
--cli-input-json file://data.json
```
File input data.json adalah sebagai berikut. Kunci `Sqls` JSON menunjukkan ada beberapa pernyataan SQL. Nilai `Arn` JSON berisi nama workgroup. Nilai `RoleArn` JSON berisi peran IAM yang digunakan untuk menjalankan SQL seperti yang dijelaskan sebelumnya.
```
{
"Rule": "test-redshift-serverless-workgroup-data",
"EventBusName": "default",
"Targets": [
{
"Id": "2",
"Arn": "arn:aws:redshift-serverless:us-east-1:123456789012:workgroup/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"RoleArn": "arn:aws:iam::123456789012:role/Administrator",
"RedshiftDataParameters": {
"Database": "dev",
"Sqls": ["select 1;", "select 2;", "select 3;"],
"StatementName": "test-redshift-serverless-workgroup-data",
"WithEvent": true
}
}
]
}
```
# Memantau API Data
Pemantauan adalah bagian penting untuk menjaga keandalan, ketersediaan, dan kinerja API Data dan AWS solusi Anda yang lain. AWS menyediakan alat pemantauan berikut untuk menonton API Data, melaporkan ketika ada sesuatu yang salah, dan mengambil tindakan otomatis bila perlu:
+ Amazon EventBridge dapat digunakan untuk mengotomatiskan AWS layanan Anda dan merespons secara otomatis peristiwa sistem, seperti masalah ketersediaan aplikasi atau perubahan sumber daya. Acara dari AWS layanan dikirimkan ke EventBridge dalam waktu nyaris nyata. Anda dapat menuliskan aturan sederhana untuk menunjukkan peristiwa mana yang sesuai kepentingan Anda, dan tindakan otomatis mana yang diambil ketika suatu peristiwa sesuai dengan suatu aturan. Untuk informasi selengkapnya, lihat [Panduan EventBridge Pengguna Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/).
+ AWS CloudTrail menangkap panggilan API dan peristiwa terkait yang dibuat oleh atau atas nama AWS akun Anda dan mengirimkan file log ke bucket Amazon S3 yang Anda tentukan. Anda dapat mengidentifikasi pengguna dan akun mana yang dipanggil AWS, alamat IP sumber dari mana panggilan dilakukan, dan kapan panggilan terjadi. Untuk mempelajari selengkapnya tentang cara Amazon Redshift terintegrasi AWS CloudTrail, lihat [Logging](https://docs.aws.amazon.com/redshift/latest/mgmt/logging-with-cloudtrail.html) with. CloudTrail Untuk informasi selengkapnya CloudTrail, lihat [Panduan AWS CloudTrail Pengguna](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
**Topics**
+ [Memantau peristiwa untuk Amazon Redshift Data API di Amazon EventBridge](data-api-monitoring-events.md)
# Memantau peristiwa untuk Amazon Redshift Data API di Amazon EventBridge
Anda dapat memantau peristiwa API Data di EventBridge, yang mengirimkan aliran data real-time dari aplikasi, aplikasi software-as-a-service (SaaS), dan layanan Anda sendiri. AWS EventBridge merutekan data tersebut ke target seperti AWS Lambda dan Amazon SNS. Peristiwa ini sama dengan yang muncul di CloudWatch Peristiwa, yang memberikan aliran peristiwa sistem yang mendekati waktu nyata yang menggambarkan perubahan sumber daya. AWS Acara dikirim ke akun yang berisi database Amazon Redshift. Misalnya, jika Anda berperan di akun lain, acara akan dikirim ke akun tersebut. Untuk informasi selengkapnya, lihat [ EventBridge Acara Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) *di Panduan EventBridge Pengguna Amazon.* .
Peristiwa API data dikirim saat operasi `ExecuteStatement` atau `BatchExecuteStatement` API menetapkan `WithEvent` opsi ke`true`. `state`Bidang acara berisi salah satu nilai berikut:
+ DIBATALKAN - Proses kueri dihentikan oleh pengguna.
+ GAGAL — Query run gagal.
+ SELESAI - Kueri telah selesai berjalan.
Acara disampaikan secara terjamin. Untuk informasi selengkapnya, lihat [Acara dari AWS layanan](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-service-event.html) di *Panduan EventBridge Pengguna Amazon*.
## Contoh untuk acara selesai Data API
Contoh berikut menunjukkan peristiwa untuk Data API saat operasi `ExecuteStatement` API selesai. Dalam contoh ini, pernyataan bernama `test.testtable` selesai berjalan.
```
{
"version": "0",
"id": "18e7079c-dd4b-dd64-caf9-e2a31640dab0",
"detail-type": "Redshift Data Statement Status Change",
"source": "aws.redshift-data",
"account": "123456789012",
"time": "2020-10-01T21:14:26Z",
"region": "us-east-1",
"resources": [
"arn:aws:redshift:us-east-1:123456789012:cluster:redshift-cluster-1"
],
"detail": {
"principal": "arn:aws:iam::123456789012:user/myuser",
"statementName": "test.testtable",
"statementId": "dd2e1ec9-2ee3-49a0-819f-905fa7d75a4a",
"redshiftQueryId": -1,
"state": "FINISHED",
"rows": 1,
"expireAt": 1601673265
}
}
```
# Menggunakan AWS KMS dengan Amazon Redshift Data API
Saat Anda mengenkripsi klaster Amazon Redshift atau grup kerja Redshift Tanpa Server dengan kunci yang dikelola pelanggan, Amazon Redshift Data API menggunakan kunci yang dikelola pelanggan yang sama untuk menyimpan dan mengenkripsi kueri dan hasil Anda.
Data API mengenkripsi data Anda secara default untuk melindungi informasi sensitif, seperti teks kueri dan hasil kueri. Ini menggunakan kunci AWS KMS enkripsi yang dimiliki oleh AWS untuk perlindungan ini.
Enkripsi default untuk data saat istirahat mengurangi overhead operasional dan kompleksitas saat Anda melindungi data sensitif. Pendekatan ini membantu Anda membangun aplikasi aman yang memenuhi kepatuhan enkripsi yang ketat dan persyaratan peraturan.
## Menggunakan hibah di AWS KMS
Data API memerlukan hibah untuk menggunakan kunci yang dikelola pelanggan Anda.
Saat Anda menelepon `ExecuteStatement` atau `BatchExecuteStatement` melawan kluster yang dienkripsi dengan kunci yang dikelola pelanggan, Amazon Redshift membuat hibah atas nama Anda dengan mengirimkan [https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)permintaan ke. AWS KMS AWS KMS menggunakan hibah untuk memberikan akses Data API ke kunci KMS di akun Anda.
Data API memerlukan hibah untuk menggunakan kunci terkelola pelanggan Anda untuk operasi berikut:
+ Kirim [https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html)permintaan AWS KMS untuk mengenkripsi metadata kueri dengan kunci terkelola pelanggan Anda.
+ Kirim [https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)permintaan AWS KMS untuk menghasilkan kunci data yang dienkripsi oleh kunci terkelola pelanggan Anda.
+ Kirim [https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)permintaan AWS KMS untuk mendekripsi kunci data terenkripsi sehingga mereka dapat mengenkripsi data Anda.
Anda dapat mencabut akses ke hibah atau menghapus akses Amazon Redshift ke kunci yang dikelola pelanggan kapan saja. Jika Anda melakukannya, API Data tidak dapat lagi mengakses data yang dienkripsi oleh kunci yang dikelola pelanggan Anda, yang memengaruhi operasi yang bergantung pada data tersebut. Misalnya, jika Anda mencoba mengambil hasil kueri atau melacak status kueri setelah mencabut hibah, API Data akan mengembalikan file. `AccessDeniedException`
## Kebijakan utama untuk kunci terkelola pelanggan Anda
Kebijakan utama mengontrol akses ke kunci yang dikelola pelanggan Anda. Setiap kunci yang dikelola pelanggan harus memiliki persis satu kebijakan utama, yang berisi pernyataan yang menentukan siapa yang dapat menggunakan kunci dan bagaimana mereka dapat menggunakannya. Saat membuat kunci terkelola pelanggan, Anda dapat menentukan kebijakan kunci. Untuk informasi selengkapnya, lihat [Kunci terkelola pelanggan](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-mgn-key) di *Panduan AWS Key Management Service Pengembang*.
Untuk menggunakan kunci yang dikelola pelanggan dengan API Data, Anda harus terlebih dahulu mengizinkan akses ke Amazon Redshift. Operasi API berikut harus diizinkan dalam kebijakan utama:
+ `kms:CreateGrant`— Menambahkan hibah ke kunci yang dikelola pelanggan. Memberikan akses kontrol ke AWS KMS kunci tertentu, yang memungkinkan akses untuk memberikan operasi yang diperlukan Amazon Redshift. Untuk informasi selengkapnya, lihat [Menggunakan hibah di AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations).
Berikut ini adalah contoh kebijakan kunci:
```
"Statement":[
{
"Sid":"Allow access to principals authorized to use Amazon Redshift",
"Effect":"Allow",
"Principal":{
"AWS":"*"
},
"Action":[
"kms:DescribeKey",
"kms:CreateGrant"
],
"Resource":"*",
"Condition":{
"StringEquals":{
"kms:ViaService":"redshift.amazonaws.com",
"kms:CallerAccount":"111122223333"
}
}
},
{
"Sid":"AllowKeyAdministratorsAccess",
"Effect":"Allow",
"Principal":{
"AWS":"arn:aws:iam::111122223333:role/ExampleAdminRole"
},
"Action":"kms:*",
"Resource":"*"
},
{
"Sid":"AllowKeyUseForExampleRole",
"Effect":"Allow",
"Principal":{
"AWS":"arn:aws:iam::111122223333:role/ExampleUserRole"
},
"Action":[
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource":"*"
}
]
```
## Konteks enkripsi API data
Konteks enkripsi adalah kumpulan opsional pasangan kunci-nilai yang berisi informasi kontekstual tambahan tentang data. AWS KMS menggunakan konteks enkripsi sebagai data otentikasi tambahan untuk mendukung enkripsi yang diautentikasi. Bila Anda menyertakan konteks enkripsi dalam permintaan untuk mengenkripsi data, AWS KMS mengikat konteks enkripsi ke data terenkripsi. Untuk mendekripsi data, Anda harus menyertakan konteks enkripsi yang sama dalam permintaan.
Data API menggunakan tiga pasangan nilai kunci konteks enkripsi yang sama di semua operasi AWS KMS kriptografi untuk kluster yang disediakan:
+ `aws:redshift:arn`— Nama Sumber Daya Amazon (ARN) cluster
+ `aws:redshift:createtime`— Stempel waktu saat Anda meminta pembuatan cluster
+ `serviceName` – `RedshiftDataAPI`
```
"EncryptionContextSubset": {
"aws:redshift:arn": "arn:aws:redshift:us-east-1:123456789012:cluster:redshift-cluster",
"aws:redshift:createtime": "20250815T0000Z",
"serviceName": "RedshiftDataAPI",
}
```
Data API menggunakan dua pasangan nilai kunci konteks enkripsi di semua operasi AWS KMS kriptografi untuk grup kerja tanpa server:
+ `aws:redshift-serverless:arn`— Nama Sumber Daya Amazon (ARN) namespace
+ `serviceName`— RedshiftData API
```
"EncryptionContextSubset": {
"aws:redshift-serverless:arn": "arn:aws:redshift-serverless:us-east-1:123456789012:namespace:12345678-1234-1234-1234-123456789012",
"serviceName": "RedshiftDataAPI"
}
```
Untuk informasi selengkapnya tentang enkripsi, lihat [Pengantar detail kriptografi. AWS KMS](https://docs.aws.amazon.com/kms/latest/cryptographic-details/intro.html) Untuk informasi selengkapnya tentang Amazon Redshift dan AWS KMS integrasi, lihat [Cara Amazon Redshift menggunakan](https://docs.aws.amazon.com/kms/latest/developerguide/services-redshift.html). AWS KMS