Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Autentikasi basis data IAMuntuk MariaDB, MySQL, dan PostgreSQL
Anda dapat mengautentikasi ke instans DB Anda menggunakan otentikasi database AWS Identity and Access Management (IAM). Autentikasi basis data IAM berfungsi dengan MariaDB, MySQL, dan PostgreSQL. Dengan metode autentikasi ini, Anda tidak perlu menggunakan kata sandi saat menghubungkan dengan instans basis data. Sebagai gantinya, gunakan token autentikasi.
*Token autentikasi* adalah string karakter unik yang dihasilkan Amazon RDS sesuai permintaan. Token otentikasi dihasilkan menggunakan AWS Signature Version 4. Setiap token memiliki masa pakai 15 menit. Anda tidak perlu menyimpan kredensial pengguna di basis data karena autentikasi dikelola secara eksternal menggunakan IAM. Anda juga masih dapat menggunakan autentikasi basis data standar. Token hanya digunakan untuk autentikasi dan tidak memengaruhi sesi setelah dibuat.
Autentikasi basis data IAM memberikan manfaat berikut:
+ Lalu lintas jaringan ke dan dari basis data dienkripsi menggunakan Lapisan Soket Aman (SSL) atau Keamanan Lapisan Pengangkutan (TLS). Untuk informasi selengkapnya tentang penggunaan SSL/TLS Amazon RDS Aurora, lihat. [](UsingWithRDS.SSL.md)
+ Anda dapat menggunakan IAM untuk mengelola akses ke sumber daya basis data Anda secara terpusat, bukan mengelola akses satu per satu pada setiap instans DB.
+ Untuk aplikasi yang berjalan di Amazon EC2, Anda dapat menggunakan kredensial profil khusus untuk instans EC2 untuk mengakses basis data, bukan menggunakan kata sandi, untuk keamanan yang lebih baik.
Secara umum, pertimbangkan untuk menggunakan autentikasi basis data IAM ketika aplikasi Anda membuat kurang dari 200 koneksi per detik, dan Anda tidak ingin mengelola nama pengguna dan kata sandi secara langsung dalam kode aplikasi Anda.
Driver Amazon Web Services (AWS) JDBC mendukung autentikasi database IAM. Untuk informasi selengkapnya, lihat [Plugin Autentikasi AWS IAM di repositori](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) [Driver Amazon Web Services (AWS) JDBC](https://github.com/aws/aws-advanced-jdbc-wrapper). GitHub
Driver Python Amazon Web Services (AWS) mendukung otentikasi database IAM. Untuk informasi selengkapnya, lihat [Plugin Autentikasi AWS IAM](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) di repositori [Amazon Web Services ()AWS Python](https://github.com/aws/aws-advanced-python-wrapper) Driver. GitHub
Arahkan topik berikut untuk mempelajari proses menyetel IAM untuk otentikasi DB:
+ [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Menghubungkan ke instans DB menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.Connecting.md)
## Ketersediaan wilayah dan versi
Ketersediaan dan dukungan fitur bervariasi di seluruh versi tertentu dari setiap mesin database. Untuk informasi selengkapnya tentang ketersediaan engine, versi, dan Wilayah dengan autentikasi database Amazon RDS dan IAM, lihat. [Daerah yang Didukung dan mesin DB untuk otentikasi database IAM di Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.IamDatabaseAuthentication.md)
## Dukungan CLI dan SDK
Autentikasi database IAM tersedia untuk [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html)dan untuk bahasa khusus berikut: AWS SDKs
+ [AWS SDK untuk .NET](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/RDS/TRDSAuthTokenGenerator.html)
+ [AWS SDK untuk C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/class_aws_1_1_r_d_s_1_1_r_d_s_client.html#ae134ffffed5d7672f6156d324e7bd392)
+ [AWS SDK untuk Go](https://docs.aws.amazon.com/sdk-for-go/api/service/rds/#pkg-overview)
+ [AWS SDK untuk Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/rds/RdsUtilities.html)
+ [AWS SDK untuk JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_rds_signer.html)
+ [AWS SDK untuk PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.Rds.AuthTokenGenerator.html)
+ [AWS SDK untuk Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.generate_db_auth_token)
+ [AWS SDK untuk Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/RDS/AuthTokenGenerator.html)
## Batasan untuk autentikasi basis data IAM
Saat menggunakan autentikasi basis data IAM, batasan berikut berlaku:
+ Saat ini, autentikasi basis data IAM tidak mendukung kunci konteks kondisi global.
Untuk informasi selengkapnya tentang kunci konteks kondisi global, lihat [Kunci konteks kondisi global AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dalam *Panduan Pengguna IAM*.
+ Untuk PostgreSQL, jika peran IAM (`rds_iam`) ditambahkan ke pengguna (termasuk pengguna master RDS), autentikasi IAM akan lebih diprioritaskan daripada autentikasi kata sandi, sehingga pengguna harus login sebagai pengguna IAM.
+ Untuk PostgreSQL, Amazon RDS tidak mendukung pengaktifan metode autentikasi IAM dan Kerberos secara bersamaan.
+ Untuk PostgreSQL, Anda tidak dapat menggunakan autentikasi IAM untuk membuat koneksi replikasi.
+ Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir instans DB untuk menghasilkan token autentikasi.
+ CloudWatch dan CloudTrail jangan mencatat otentikasi IAM. Layanan ini tidak melacak panggilan `generate-db-auth-token` API yang mengotorisasi peran IAM untuk mengaktifkan koneksi database.
+ Anda harus memiliki antara 300 dan 1000 MiB memori tambahan pada database Anda untuk konektivitas yang andal. Untuk melihat memori yang dibutuhkan untuk beban kerja Anda, bandingkan kolom RES untuk proses RDS dalam daftar proses Enhanced Monitoring sebelum dan sesudah mengaktifkan autentikasi IAM DB. Lihat [Melihat metrik OS di konsol RDS](USER_Monitoring.OS.Viewing.md).
Jika Anda menggunakan instance kelas burstable, hindari kehabisan memori dengan mengurangi memori yang digunakan oleh parameter lain seperti buffer dan cache dengan jumlah yang sama.
+ Autentikasi IAM DB tidak didukung untuk RDS di Outposts untuk mesin apa pun.
## Rekomendasi untuk autentikasi basis data IAM
Kami merekomendasikan hal berikut saat menggunakan autentikasi basis data IAM:
+ Gunakan autentikasi basis data IAM ketika aplikasi Anda membutuhkan tidak lebih dari 200 koneksi autentikasi basis data IAM per detik.
Mesin basis data yang berfungsi dengan Amazon RDS tidak memberlakukan batasan apa pun untuk percobaan autentikasi per detik. Namun, ketika Anda menggunakan autentikasi basis data IAM, aplikasi Anda harus membuat token autentikasi. Aplikasi Anda kemudian menggunakan token tersebut untuk terhubung ke instans DB. Jika Anda melebihi batas maksimum untuk koneksi baru per detik, maka overhead tambahan dari autentikasi basis data IAM dapat menyebabkan throttling koneksi.
Pertimbangkan untuk menggunakan pooling koneksi di aplikasi Anda untuk mengurangi pembuatan koneksi yang konstan. Cara ini dapat mengurangi overhead dari autentikasi DB IAM dan memungkinkan aplikasi Anda menggunakan kembali koneksi yang ada. Alternatifnya, pertimbangkan untuk menggunakan Proksi RDS untuk kasus penggunaan ini. Proksi RDS memiliki biaya tambahan. Lihat [Harga Proksi RDS](https://aws.amazon.com/rds/proxy/pricing/).
+ Ukuran token autentikasi basis data IAM tergantung pada banyak hal termasuk jumlah tag IAM, kebijakan layanan IAM, panjang ARN, serta properti IAM dan basis data lainnya. Ukuran minimum token ini umumnya sekitar 1 KB tetapi bisa lebih besar. Karena token ini digunakan sebagai kata sandi dalam string koneksi ke database menggunakan otentikasi IAM, Anda harus memastikan bahwa driver database Anda (misalnya, ODBC) alat and/or apa pun tidak membatasi atau memotong token ini karena ukurannya. Token yang terpotong akan menyebabkan kegagalan validasi autentikasi oleh basis data dan IAM.
+ Jika Anda menggunakan kredensial sementara saat membuat token autentikasi basis data IAM, kredensial sementara masih harus valid saat menggunakan token autentikasi basis data IAM untuk membuat permintaan koneksi.
## Kunci konteks kondisi AWS global yang tidak didukung
Autentikasi database IAM tidak mendukung subset kunci konteks kondisi AWS global berikut.
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`
Untuk informasi selengkapnya, lihat [Kunci konteks kondisi global AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dalam *Panduan Pengguna IAM*.
# Mengaktifkan dan menonaktifkan autentikasi basis data IAM
Secara default, autentikasi basis data IAM dinonaktifkan di instans DB. Anda dapat mengaktifkan atau menonaktifkan autentikasi database IAM menggunakan Konsol Manajemen AWS, AWS CLI, atau API.
Anda dapat mengaktifkan autentikasi basis data IAM saat Anda melakukan salah satu tindakan berikut:
+ Untuk membuat instans DB yang baru dengan autentikasi basis data IAM diaktifkan, lihat [Membuat instans DB Amazon RDS](USER_CreateDBInstance.md).
+ Untuk memodifikasi instans DB untuk mengaktifkan autentikasi basis data IAM, lihat [Memodifikasi instans DB Amazon RDS](Overview.DBInstance.Modifying.md).
+ Untuk memulihkan instans DB dari snapshot dengan autentikasi basis data IAM diaktifkan, lihat [Memulihkan ke instans DB](USER_RestoreFromSnapshot.md).
+ Untuk memulihkan instans DB ke titik waktu dengan autentikasi basis data IAM diaktifkan, lihat [Memulihkan instans DB ke waktu yang ditentukan untuk Amazon RDS](USER_PIT.md).
## Konsol
Setiap alur kerja pembuatan atau modifikasi memiliki bagian **Autentikasi basis data**, tempat Anda dapat mengaktifkan atau menonaktifkan autentikasi basis data IAM. Di bagian tersebut, pilih **Kata sandi dan autentikasi basis data IAM** untuk mengaktifkan autentikasi basis data IAM.
**Untuk mengaktifkan atau menonaktifkan autentikasi basis data IAM untuk instans DB yang ada**
1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih **Basis data**.
1. Pilih instans DB yang ingin Anda ubah.
**catatan**
Pastikan bahwa instans DB kompatibel dengan autentikasi IAM. Periksa persyaratan kompatibilitas dalam [Ketersediaan wilayah dan versi](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
1. Pilih **Ubah**.
1. Di bagian **otentikasi database**, pilih **Password dan IAM database autentikasi IAM database autentikasi** untuk mengaktifkan . Pilih **Autentikasi kata sandi** atau **Kata sandi dan autentikasi Kerberos** untuk menonaktifkan autentikasi IAM.
1. Anda juga dapat memilih untuk mengaktifkan penerbitan log otentikasi IAM DB ke CloudWatch Log. Di bawah **Ekspor log**, pilih opsi **iam-db-auth-error log**. Menerbitkan log Anda ke CloudWatch Log menghabiskan penyimpanan dan Anda dikenakan biaya untuk penyimpanan itu. Pastikan untuk menghapus CloudWatch Log apa pun yang tidak lagi Anda butuhkan.
1. Pilih **Lanjutkan**.
1. Untuk segera menerapkan perubahan, pilih **Segera** di bagian **Penjadwalan modifikasi**.
1. Pilih **Modifikasi instans DB** .
## AWS CLI
Untuk membuat instans DB baru dengan otentikasi IAM dengan menggunakan AWS CLI, gunakan perintah. [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) Tentukan opsi `--enable-iam-database-authentication`, seperti yang ditunjukkan dalam contoh berikut.
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.m3.medium \
--engine MySQL \
--allocated-storage 20 \
--master-username masterawsuser \
--manage-master-user-password \
--enable-iam-database-authentication
```
Untuk memperbarui instans DB yang ada agar memiliki atau tidak memiliki autentikasi IAM, gunakan perintah AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html). Tentukan opsi `--enable-iam-database-authentication` atau `--no-enable-iam-database-authentication`, sesuai kebutuhan.
**catatan**
Pastikan bahwa instans DB kompatibel dengan autentikasi IAM. Periksa persyaratan kompatibilitas dalam [Ketersediaan wilayah dan versi](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Secara default, Amazon RDS melakukan modifikasi selama periode pemeliharaan berikutnya. Jika Anda ingin menggantinya dan mengaktifkan autentikasi DB IAM sesegera mungkin, gunakan parameter `--apply-immediately`.
Contoh berikut menunjukkan cara untuk segera mengaktifkan autentikasi IAM untuk instans DB yang sudah ada.
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--apply-immediately \
--enable-iam-database-authentication
```
Jika Anda memulihkan instans DB, gunakan salah satu AWS CLI perintah berikut:
+ `[restore-db-instance-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)`
+ `[restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)`
Pengaturan autentikasi basis data IAM akan ditetapkan secara default ke pengaturan untuk snapshot sumber. Untuk mengubah pengaturan ini, atur opsi `--enable-iam-database-authentication` atau `--no-enable-iam-database-authentication` sebagaimana diperlukan.
## API RDS
Untuk membuat instans DB baru dengan autentikasi IAM dengan menggunakan API, gunakan operasi API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Atur parameter `EnableIAMDatabaseAuthentication` ke `true`.
Untuk memperbarui instans DB yang ada agar memiliki autentikasi IAM, gunakan operasi API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html). Atur parameter `EnableIAMDatabaseAuthentication` ke `true` untuk mengaktifkan autentikasi IAM, atau `false` untuk menonaktifkannya.
**catatan**
Pastikan bahwa instans DB kompatibel dengan autentikasi IAM. Periksa persyaratan kompatibilitas dalam [Ketersediaan wilayah dan versi](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Jika Anda memulihkan instans DB, gunakan salah satu operasi API berikut:
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)
Pengaturan autentikasi basis data IAM akan ditetapkan secara default ke pengaturan untuk snapshot sumber. Untuk mengubah pengaturan ini, atur parameter `EnableIAMDatabaseAuthentication` ke `true` untuk mengaktifkan autentikasi IAM, atau `false` untuk menonaktifkannya.
# Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM
Untuk memungkinkan pengguna atau peran terhubung ke instans DB, Anda harus membuat kebijakan IAM. Setelah itu, lampirkan kebijakan tersebut ke set izin atau peran.
**catatan**
Untuk mempelajari selengkapnya tentang kebijakan IAM, lihat [Manajemen identitas dan akses untuk Amazon RDS](UsingWithRDS.IAM.md).
Contoh kebijakan berikut memungkinkan pengguna terhubung ke instans DB menggunakan autentikasi basis data IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:db-ABCDEFGHIJKL01234/db_user"
]
}
]
}
```
------
**penting**
Pengguna dengan izin administrator dapat mengakses instans DB tanpa izin eksplisit dalam kebijakan IAM. Jika Anda ingin membatasi akses administrator ke instans DB, Anda dapat membuat peran IAM yang dengan izin istimewa yang sesuai dan menetapkannya ke administrator.
**catatan**
Jangan samakan awalan `rds-db:` dengan awalan operasi API RDS lain yang diawali dengan `rds:`. Anda menggunakan awalan `rds-db:` dan tindakan `rds-db:connect` hanya untuk autentikasi basis data IAM. Hal ini tidak berlaku dalam konteks lainnya.
Contoh kebijakan ini mencakup satu pernyataan dengan elemen berikut:
+ `Effect` – Tentukan `Allow` untuk memberikan akses ke instans DB. Jika Anda tidak secara eksplisit mengizinkan akses, maka akses ditolak secara default.
+ `Action` – Tentukan `rds-db:connect` untuk mengizinkan koneksi ke instans DB.
+ `Resource` – Tentukan Amazon Resource Name (ARN) yang menjelaskan satu akun basis data dalam satu instans DB. Format ARN adalah sebagai berikut.
```
arn:aws:rds-db:region:account-id:dbuser:DbiResourceId/db-user-name
```
Dalam format ini, ganti hal berikut:
+ `region`adalah AWS Region untuk instans DB. Dalam contoh kebijakan, AWS Wilayah adalah`us-east-2`.
+ `account-id`adalah nomor AWS akun untuk instans DB. Dalam contoh kebijakan, nomor akun adalah `1234567890`. Pengguna harus berada di akun yang sama dengan akun untuk instans DB.
Untuk melakukan akses lintas akun, buat peran IAM dengan kebijakan yang ditunjukkan di atas di akun untuk instans DB dan izinkan akun Anda yang lain untuk mengambil peran tersebut.
+ `DbiResourceId` adalah pengidentifikasi untuk instans DB. Pengenal ini unik untuk AWS Wilayah dan tidak pernah berubah. Dalam contoh kebijakan, pengidentifikasi adalah `db-ABCDEFGHIJKL01234`.
Untuk menemukan ID sumber daya instans DB di Amazon Aurora Amazon RDS , pilih cluster DB untuk melihat detailnya. Konsol Manajemen AWS Kemudian, pilih tab **Konfigurasi**. **ID Sumber Daya** ditampilkan di bagian **Konfigurasi**.
Atau, Anda dapat menggunakan AWS CLI perintah untuk mencantumkan pengenal dan sumber daya IDs untuk semua instans DB Anda di AWS Wilayah saat ini, seperti yang ditunjukkan berikut.
```
aws rds describe-db-instances --query "DBInstances[*].[DBInstanceIdentifier,DbiResourceId]"
```
Jika Anda menggunakan Amazon Aurora, tentukan `DbClusterResourceId`, bukan `DbiResourceId`. Untuk informasi selengkapnya, lihat [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html) dalam *Panduan Pengguna Amazon Aurora*.
**catatan**
Jika Anda terhubung ke basis data melalui Proksi RDS, tentukan ID sumber daya proksi, seperti `prx-ABCDEFGHIJKL01234`. Untuk informasi tentang menggunakan autentikasi basis data IAM dengan Proksi RDS, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
+ `db-user-name` adalah nama akun basis data untuk dikaitkan dengan autentikasi IAM. Dalam contoh kebijakan, akun basis data adalah `db_user`.
Anda dapat membangun yang lain ARNs untuk mendukung berbagai pola akses. Kebijakan berikut memungkinkan akses ke dua akun basis data yang berbeda dalam instans DB.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/jane_doe",
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/mary_roe"
]
}
]
}
```
------
Kebijakan berikut menggunakan karakter “\$1” untuk mencocokkan semua instans DB dan akun database untuk AWS akun dan AWS Wilayah tertentu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:*/*"
]
}
]
}
```
------
Kebijakan berikut cocok dengan semua instans DB untuk AWS akun dan AWS Wilayah tertentu. Namun, kebijakan ini hanya memberikan akses ke instans DB yang memiliki akun basis data `jane_doe`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:*/jane_doe"
]
}
]
}
```
------
Pengguna atau peran hanya memiliki akses ke basis data yang aksesnya dimiliki oleh pengguna basis data tersebut. Misalnya, anggaplah instans DB Anda memiliki basis data bernama *dev*, dan basis data lain bernama *uji*. Jika pengguna basis data `jane_doe` hanya memiliki akses ke *dev*, setiap pengguna atau peran yang mengakses instans DB tersebut dengan pengguna `jane_doe` juga hanya akan memiliki akses ke *dev*. Pembatasan akses ini juga berlaku untuk objek basis data lain, seperti tabel, tampilan, dan sebagainya.
Administrator harus membuat kebijakan IAM yang memberikan izin pada entitas untuk melakukan operasi API tertentu pada sumber daya yang diperlukan. Administrator kemudian harus melampirkan kebijakan tersebut ke set izin atau peran yang memerlukan izin tersebut. Untuk contoh kebijakan, lihat [Contoh kebijakan berbasis identitas untuk Amazon RDS](security_iam_id-based-policy-examples.md).
## Melampirkan kebijakan IAM ke set izin atau peran
Setelah membuat kebijakan IAM untuk memungkinkan autentikasi basis data, Anda perlu melampirkan kebijakan tersebut ke set izin atau peran. Untuk tutorial tentang topik ini, lihat [Buat dan lampirkan kebijakan yang dikelola pelanggan pertama Anda](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) dalam *Panduan Pengguna IAM*.
Saat mengikuti tutorial ini, Anda dapat menggunakan salah satu contoh kebijakan yang ditunjukkan dalam bagian ini sebagai titik awal dan menyesuaikannya dengan kebutuhan Anda. Di akhir tutorial, Anda akan memiliki set izin dengan kebijakan terlampir yang dapat menggunakan tindakan `rds-db:connect`.
**catatan**
Anda dapat memetakan beberapa set izin atau peran ke akun pengguna basis data yang sama. Misalnya, anggaplah kebijakan IAM Anda telah menentukan ARN sumber daya berikut.
```
arn:aws:rds-db:us-east-2:123456789012:dbuser:db-12ABC34DEFG5HIJ6KLMNOP78QR/jane_doe
```
Jika Anda melampirkan kebijakan ke *Jane*, *Bob*, dan *Diego*, maka masing-masing pengguna tersebut dapat terhubung ke klaster DB yang telah ditentukan menggunakan akun basis data `jane_doe`.
# Membuat akun basis data menggunakan autentikasi IAM
Dengan autentikasi basis data IAM, Anda tidak perlu menetapkan kata sandi basis data ke akun pengguna yang Anda buat. Jika Anda menghapus pengguna yang dipetakan ke akun basis data, Anda juga harus menghapus akun basis data dengan pernyataan `DROP USER`.
**catatan**
Nama pengguna yang digunakan untuk autentikasi IAM harus sesuai dengan huruf besar/kecil nama pengguna dalam basis data.
**Topics**
+ [Menggunakan autentikasi IAM dengan MariaDB dan MySQL](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## Menggunakan autentikasi IAM dengan MariaDB dan MySQL
Dengan MariaDB dan MySQL, otentikasi `AWSAuthenticationPlugin` ditangani AWS oleh —sebuah plugin yang disediakan yang bekerja mulus dengan IAM untuk mengautentikasi pengguna Anda. Hubungkan ke instans DB sebagai pengguna master atau pengguna lain yang dapat membuat pengguna dan memberikan hak akses. Setelah terhubung, berikan pernyataan `CREATE USER`, seperti yang ditunjukkan pada contoh berikut.
```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS';
```
Klausa `IDENTIFIED WITH` memungkinkan MariaDB dan MySQL menggunakan `AWSAuthenticationPlugin` untuk mengautentikasi akun basis data (`jane_doe`). Klausa `AS 'RDS'` mengacu pada metode autentikasi. Pastikan nama pengguna basis data yang ditentukan sama dengan sumber daya dalam kebijakan IAM untuk akses basis data IAM. Untuk informasi selengkapnya, lihat [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md).
**catatan**
Jika Anda melihat pesan berikut, itu berarti plugin AWS-provided tidak tersedia untuk instans DB saat ini.
`ERROR 1524 (HY000): Plugin 'AWSAuthenticationPlugin' is not loaded`
Untuk mengatasi kesalahan ini, verifikasikan bahwa Anda menggunakan konfigurasi yang didukung dan bahwa Anda telah mengaktifkan autentikasi basis data IAM di instans DB Anda. Untuk informasi lebih lanjut, lihat [Ketersediaan wilayah dan versi](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) dan [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md).
Setelah membuat akun menggunakan `AWSAuthenticationPlugin`, Anda mengelolanya dengan cara yang sama seperti akun basis data lainnya. Misalnya, Anda dapat memodifikasi hak akses akun dengan pernyataan `GRANT` dan `REVOKE`, atau memodifikasi berbagai atribut akun dengan pernyataan `ALTER USER`.
Lalu lintas jaringan database dienkripsi menggunakan SSL/TLS saat menggunakan IAM. Untuk mengizinkan koneksi SSL, ubah akun pengguna dengan perintah berikut.
```
ALTER USER 'jane_doe'@'%' REQUIRE SSL;
```
##
Untuk menggunakan autentikasi IAM dengan PostgreSQL, hubungkan ke instans DB sebagai pengguna master atau pengguna lain yang dapat membuat pengguna dan memberikan hak istimewa. Setelah terhubung, buat pengguna basis data lalu berikan peran `rds_iam` kepada pengguna tersebut seperti yang ditunjukkan pada contoh berikut.
```
CREATE USER db_userx;
GRANT rds_iam TO db_userx;
```
Pastikan nama pengguna basis data yang ditentukan sama dengan sumber daya dalam kebijakan IAM untuk akses basis data IAM. Untuk informasi selengkapnya, lihat [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Anda harus memberikan `rds_iam` peran untuk menggunakan otentikasi IAM. Anda juga dapat menggunakan keanggotaan bersarang atau hibah tidak langsung dari peran tersebut.
# Menghubungkan ke instans DB menggunakan autentikasi IAM
Dengan autentikasi basis data IAM, Anda menggunakan token autentikasi ketika Anda terhubung ke instans DB Anda. *Token autentikasi* adalah string karakter yang Anda gunakan sebagai pengganti kata sandi. Setelah Anda membuat token autentikasi, token tersebut berlaku selama 15 menit sebelum kedaluwarsa. Jika Anda mencoba terhubung menggunakan token yang kedaluwarsa, permintaan koneksi ditolak.
Setiap token autentikasi harus disertai dengan tanda tangan yang valid, menggunakan AWS Signature versi 4. (Untuk informasi selengkapnya, lihat [Proses penandatanganan Versi Tanda Tangan 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) di * Referensi Umum AWS.* ) SDK AWS CLI dan AWS SDK, seperti AWS SDK untuk Java or AWS SDK untuk Python (Boto3), dapat secara otomatis menandatangani setiap token yang Anda buat.
Anda dapat menggunakan token otentikasi saat Anda terhubung ke Amazon RDS Amazon dari layanan AWS lain, seperti. AWS Lambda Dengan menggunakan token, Anda tidak perlu menempatkan kata sandi dalam kode Anda. Atau, Anda dapat menggunakan AWS SDK untuk membuat dan menandatangani token otentikasi secara terprogram secara terprogram.
Setelah Anda memiliki token autentikasi IAM yang telah ditandatangani, Anda dapat terhubung ke instans DB Amazon RDS. Berikut ini, Anda dapat mengetahui cara melakukan ini menggunakan alat baris perintah atau AWS SDK, seperti AWS SDK untuk Java atau AWS SDK untuk Python (Boto3).
Untuk informasi selengkapnya, lihat postingan blog berikut ini:
+ [Gunakan autentikasi IAM untuk terhubung dengan SQL Workbench/J ke Aurora MySQL atau Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/)
+ [Menggunakan autentikasi IAM untuk terhubung dengan pgAdmin Amazon Aurora PostgreSQL atau Amazon RDS for PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke instans DB menggunakan autentikasi IAM:
+ [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [Menghubungkan ke instans DB Anda menggunakan autentikasi IAM dengan driver AWS](IAMDBAuth.Connecting.Drivers.md)
+ [Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dari baris perintah: AWS CLI dan klien mysql](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dari baris perintah: AWS CLI dan klien psql](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dan AWS SDK untuk .NET](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Go](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Java](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Python (Boto3)](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# Menghubungkan ke instans DB Anda menggunakan autentikasi IAM dengan driver AWS
AWS Rangkaian driver telah dirancang untuk memberikan dukungan untuk waktu peralihan dan failover yang lebih cepat, dan otentikasi dengan, AWS Identity and Access Management (IAM) AWS Secrets Manager, dan Federated Identity. AWS Driver mengandalkan pemantauan status instans DB dan menyadari topologi instance untuk menentukan penulis baru. Pendekatan ini mengurangi waktu peralihan dan failover menjadi satu digit detik, dibandingkan dengan puluhan detik untuk driver open-source.
[Untuk informasi selengkapnya tentang AWS driver, lihat driver bahasa yang sesuai untuk RDS Anda untuk [MariaDB, RDS untuk](MariaDB.Connecting.Drivers.md#MariaDB.Connecting.JDBCDriver)[MySQL, atau RDS untuk instans PostgreSQL](MySQL.Connecting.Drivers.md#MySQL.Connecting.JDBCDriver) DB.](PostgreSQL.Connecting.JDBCDriver.md)
**catatan**
Satu-satunya fitur yang didukung untuk RDS untuk MariaDB adalah otentikasi AWS Secrets Manager dengan, (IAM) AWS Identity and Access Management , dan Federated Identity.
# Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dari baris perintah: AWS CLI dan klien mysql
Anda dapat terhubung dari baris perintah ke cluster dengan AWS CLI alat baris perintah `mysql` dan seperti yang dijelaskan berikut.
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke instans DB menggunakan autentikasi IAM:
+ [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**catatan**
Untuk informasi tentang menghubungkan ke database Anda menggunakan SQL Workbench/J dengan autentikasi IAM, lihat posting blog [Menggunakan otentikasi IAM untuk terhubung dengan SQL ke Workbench/J Aurora MySQL atau Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/).
**Topics**
+ [Membuat token autentikasi IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [Menghubungkan ke instans DB](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)
## Membuat token autentikasi IAM
Contoh berikut menunjukkan cara mendapatkan token autentikasi yang ditandatangani menggunakan AWS CLI.
```
aws rds generate-db-auth-token \
--hostname rdsmysql.123456789012.us-west-2.rds.amazonaws.com \
--port 3306 \
--region us-west-2 \
--username jane_doe
```
Dalam contoh, parameternya adalah sebagai berikut:
+ `--hostname` – Nama host instans DB yang ingin Anda akses
+ `--port` – Nomor port yang digunakan untuk menghubungkan ke instans DB Anda
+ `--region`— AWS Wilayah tempat instans DB berjalan
+ `--username` – Akun basis data yang ingin Anda akses
Beberapa karakter pertama dari token terlihat seperti berikut.
```
rdsmysql.123456789012.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir instans DB untuk menghasilkan token autentikasi.
## Menghubungkan ke instans DB
Format umum untuk terhubung ditampilkan sebagai berikut.
```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```
Parameternya adalah sebagai berikut:
+ `--host` – Nama host instans DB yang ingin Anda akses
+ `--port` – Nomor port yang digunakan untuk menghubungkan ke instans DB Anda
+ `--ssl-ca` – Jalur lengkap ke file sertifikat SSL yang berisi kunci publik
Untuk informasi lebih lanjut tentang SSL/TLS dukungan untuk MariaDB, lihat. [Dukungan SSL/TLS untuk instans MariaDB DB di Amazon RDS](MariaDB.Concepts.SSLSupport.md)
Untuk informasi selengkapnya tentang SSL/TLS dukungan untuk MySQL, lihat. [Dukungan SSL/TLS untuk instans MySQL DB di Amazon RDS](MySQL.Concepts.SSLSupport.md)
Untuk mengunduh sertifikat SSL, lihat [](UsingWithRDS.SSL.md).
+ `--enable-cleartext-plugin` – Nilai yang menentukan bahwa `AWSAuthenticationPlugin` harus digunakan untuk koneksi ini
Jika Anda menggunakan klien MariaDB, opsi `--enable-cleartext-plugin` tidak diperlukan.
+ `--user` – Akun basis data yang ingin Anda akses
+ `--password` – Token autentikasi IAM yang ditandatangani
Token autentikasi terdiri atas beberapa ratus karakter. Hal ini dapat sulit ditangani di baris perintah. Salah satu cara untuk mengatasinya adalah dengan menyimpan token ke variabel lingkungan, lalu menggunakan variabel tersebut saat Anda terhubung. Contoh berikut menunjukkan satu cara untuk melakukan solusi ini. Dalam contoh, */sample\$1dir/* adalah path lengkap ke file sertifikat SSL yang berisi kunci publik.
```
RDSHOST="mysqldb.123456789012.us-east-1.rds.amazonaws.com"
TOKEN="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 3306 --region us-west-2 --username jane_doe )"
mysql --host=$RDSHOST --port=3306 --ssl-ca=/sample_dir/global-bundle.pem --enable-cleartext-plugin --user=jane_doe --password=$TOKEN
```
Saat Anda terhubung menggunakan `AWSAuthenticationPlugin`, koneksi diamankan menggunakan SSL. Untuk memverifikasi hal ini, ketik berikut ini di prompt perintah `mysql>`.
```
show status like 'Ssl%';
```
Baris berikut dalam output menampilkan lebih banyak detail.
```
+---------------+-------------+
| Variable_name | Value |
+---------------+-------------+
| ... | ...
| Ssl_cipher | AES256-SHA |
| ... | ...
| Ssl_version | TLSv1.1 |
| ... | ...
+-----------------------------+
```
Jika Anda ingin terhubung ke instans DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dari baris perintah: AWS CLI dan klien psql
Anda dapat terhubung dari baris perintah ke instans DB Amazon RDS for PostgreSQL dengan AWS CLI dan alat baris perintah psql seperti yang dijelaskan berikut.
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke instans DB menggunakan autentikasi IAM:
+ [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**catatan**
Untuk informasi tentang menghubungkan ke basis data Anda menggunakan pgAdmin dengan autentikasi IAM, lihat postingan blog [Menggunakan autentikasi IAM untuk terhubung dengan pgAdmin Amazon Aurora PostgreSQL atau Amazon RDS for PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/).
**Topics**
+ [Membuat token autentikasi IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [Menghubungkan ke instans Amazon RDS PostgreSQL](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)
## Membuat token autentikasi IAM
Token autentikasi terdiri dari ratusan karakter sehingga kemungkinan menjadi sulit ditangani di baris perintah. Salah satu cara untuk mengatasi ini adalah dengan menyimpan token ke variabel lingkungan, lalu menggunakan variabel tersebut saat Anda terhubung. Contoh berikut menunjukkan bagaimana menggunakan AWS CLI untuk mendapatkan token otentikasi ditandatangani menggunakan `generate-db-auth-token` perintah, dan menyimpannya dalam variabel `PGPASSWORD` lingkungan.
```
export RDSHOST="rdspostgres.123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
```
Dalam contoh, parameter untuk perintah `generate-db-auth-token` adalah sebagai berikut:
+ `--hostname` – Nama host instans DB yang ingin Anda akses
+ `--port` – Nomor port yang digunakan untuk menghubungkan ke instans DB Anda
+ `--region`— AWS Wilayah tempat instans DB berjalan
+ `--username` – Akun basis data yang ingin Anda akses
Beberapa karakter pertama dari token yang dihasilkan terlihat seperti berikut.
```
rdspostgres.123456789012.us-west-2.rds.amazonaws.com:5432/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir instans DB untuk menghasilkan token autentikasi.
## Menghubungkan ke instans Amazon RDS PostgreSQL
Format umum untuk menggunakan psql untuk terhubung ditampilkan sebagai berikut.
```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```
Parameternya adalah sebagai berikut:
+ `host` – Nama host instans DB yang ingin Anda akses
+ `port` – Nomor port yang digunakan untuk menghubungkan ke instans DB Anda
+ `sslmode` – Mode SSL yang akan digunakan
Saat Anda menggunakan `sslmode=verify-full`, koneksi SSL memverifikasi titik akhir instans DB di sertifikat SSL.
+ `sslrootcert` – Jalur lengkap ke file sertifikat SSL yang berisi kunci publik
Untuk informasi selengkapnya, lihat [Menggunakan SSL dengan instans DB PostgreSQL](PostgreSQL.Concepts.General.SSL.md).
Untuk mengunduh sertifikat SSL, lihat [](UsingWithRDS.SSL.md).
+ `dbname` – Basis data yang ingin Anda akses
+ `user` – Akun basis data yang ingin Anda akses
+ `password` – Token autentikasi IAM yang ditandatangani
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir instans DB untuk menghasilkan token autentikasi.
Contoh berikut menunjukkan penggunaan psql untuk terhubung. Dalam contoh, psql menggunakan variabel lingkungan `RDSHOST` untuk host dan variabel lingkungan `PGPASSWORD` untuk token yang dihasilkan. Juga, */sample\$1dir/* adalah jalur lengkap ke file sertifikat SSL yang berisi kunci publik.
```
export RDSHOST="rdspostgres.123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
psql "host=$RDSHOST port=5432 sslmode=verify-full sslrootcert=/sample_dir/global-bundle.pem dbname=DBName user=jane_doe password=$PGPASSWORD"
```
Jika Anda ingin terhubung ke instans DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dan AWS SDK untuk .NET
Anda dapat terhubung ke RDS untuk MariaDB, MySQL, atau PostgreSQL DB PostgreSQL DB cluster dengan seperti yang dijelaskan berikut. AWS SDK untuk .NET
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke instans DB menggunakan autentikasi IAM:
+ [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Contoh**
Contoh kode berikut ini menunjukkan cara membuat token autentikasi, lalu menggunakannya untuk menghubungkan ke instans DB.
Untuk menjalankan contoh kode ini, Anda memerlukan [AWS SDK untuk .NET](https://aws.amazon.com/sdk-for-net/), ditemukan di AWS situs. Paket `AWSSDK.CORE` dan `AWSSDK.RDS` diperlukan. Untuk terhubung ke instans DB, gunakan konektor database.NET untuk mesin DB, seperti untuk MariaDB atau MySQL, atau Npgsql MySqlConnector untuk PostgreSQL.
Kode ini terhubung ke instans DB MariaDB MySQL. Ubah nilai variabel berikut sesuai kebutuhan:
+ `server` – Titik akhir instans DB yang ingin Anda akses
+ `user` – Akun basis data yang ingin Anda akses
+ `database` – Basis data yang ingin Anda akses
+ `port` – Nomor port yang digunakan untuk menghubungkan ke instans DB Anda
+ `SslMode` – Mode SSL yang akan digunakan
Saat Anda menggunakan `SslMode=Required`, koneksi SSL memverifikasi titik akhir instans DB di sertifikat SSL.
+ `SslCa` – Jalur lengkap ke sertifikat SSL untuk Amazon RDS
Untuk mengunduh sertifikat, lihat [](UsingWithRDS.SSL.md).
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir instans DB untuk menghasilkan token autentikasi.
```
using System;
using System.Data;
using MySql.Data;
using MySql.Data.MySqlClient;
using Amazon;
namespace ubuntu
{
class Program
{
static void Main(string[] args)
{
var pwd = Amazon.RDS.Util.RDSAuthTokenGenerator.GenerateAuthToken(RegionEndpoint.USEast1, "mysqldb.123456789012.us-east-1.rds.amazonaws.com", 3306, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
MySqlConnection conn = new MySqlConnection($"server=mysqldb.123456789012.us-east-1.rds.amazonaws.com;user=jane_doe;database=mydB;port=3306;password={pwd};SslMode=Required;SslCa=full_path_to_ssl_certificate");
conn.Open();
// Define a query
MySqlCommand sampleCommand = new MySqlCommand("SHOW DATABASES;", conn);
// Execute a query
MySqlDataReader mysqlDataRdr = sampleCommand.ExecuteReader();
// Read all rows and output the first column in each row
while (mysqlDataRdr.Read())
Console.WriteLine(mysqlDataRdr[0]);
mysqlDataRdr.Close();
// Close connection
conn.Close();
}
}
}
```
Kode ini terhubung ke instans DB PostgreSQL.
Ubah nilai variabel berikut sesuai kebutuhan:
+ `Server` – Titik akhir instans DB yang ingin Anda akses
+ `User ID` – Akun basis data yang ingin Anda akses
+ `Database` – Basis data yang ingin Anda akses
+ `Port` – Nomor port yang digunakan untuk menghubungkan ke instans DB Anda
+ `SSL Mode` – Mode SSL yang akan digunakan
Saat Anda menggunakan `SSL Mode=Required`, koneksi SSL memverifikasi titik akhir instans DB di sertifikat SSL.
+ `Root Certificate` – Jalur lengkap ke sertifikat SSL untuk Amazon RDS
Untuk mengunduh sertifikat, lihat [](UsingWithRDS.SSL.md).
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir instans DB untuk menghasilkan token autentikasi.
```
using System;
using Npgsql;
using Amazon.RDS.Util;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
var pwd = RDSAuthTokenGenerator.GenerateAuthToken("postgresmydb.123456789012.us-east-1.rds.amazonaws.com", 5432, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
NpgsqlConnection conn = new NpgsqlConnection($"Server=postgresmydb.123456789012.us-east-1.rds.amazonaws.com;User Id=jane_doe;Password={pwd};Database=mydb;SSL Mode=Require;Root Certificate=full_path_to_ssl_certificate");
conn.Open();
// Define a query
NpgsqlCommand cmd = new NpgsqlCommand("select count(*) FROM pg_user", conn);
// Execute a query
NpgsqlDataReader dr = cmd.ExecuteReader();
// Read all rows and output the first column in each row
while (dr.Read())
Console.Write("{0}\n", dr[0]);
// Close connection
conn.Close();
}
}
}
```
Jika Anda ingin terhubung ke instans DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Go
Anda dapat terhubung ke RDS untuk MariaDB, MySQL, atau PostgreSQL DB PostgreSQL DB cluster dengan seperti yang dijelaskan berikut. AWS SDK untuk Go
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke instans DB menggunakan autentikasi IAM:
+ [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Contoh**
Untuk menjalankan contoh kode ini, Anda memerlukan [AWS SDK untuk Go](https://aws.amazon.com/sdk-for-go/), ditemukan di AWS situs.
Ubah nilai variabel berikut sesuai kebutuhan:
+ `dbName` – Basis data yang ingin Anda akses
+ `dbUser` – Akun basis data yang ingin Anda akses
+ `dbHost` – Titik akhir instans DB yang ingin Anda akses
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir instans DB untuk menghasilkan token autentikasi.
+ `dbPort` – Nomor port yang digunakan untuk menghubungkan ke instans DB Anda
+ `region`— AWS Wilayah tempat instans DB berjalan
Selain itu, pastikan pustaka yang diimpor dalam kode sampel ada di sistem Anda.
**penting**
Contoh dalam bagian ini menggunakan kode berikut untuk menyediakan kredensial yang mengakses basis data dari lingkungan lokal:
`creds := credentials.NewEnvCredentials()`
Jika Anda mengakses database dari AWS layanan, seperti Amazon EC2 atau Amazon ECS, Anda dapat mengganti kode dengan kode berikut:
`sess := session.Must(session.NewSession())`
`creds := sess.Config.Credentials`
Jika Anda membuat perubahan ini, pastikan Anda menambahkan impor berikut:
`"github.com/aws/aws-sdk-go/aws/session"`
**Topics**
+ [Menghubungkan menggunakan otentikasi IAM dan V2 AWS SDK untuk Go](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [Menghubungkan menggunakan otentikasi IAM dan V1. AWS SDK untuk Go](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)
## Menghubungkan menggunakan otentikasi IAM dan V2 AWS SDK untuk Go
Anda dapat terhubung ke instans DB menggunakan autentikasi IAM dan V2. AWS SDK untuk Go
Contoh kode berikut ini menunjukkan cara membuat token autentikasi, lalu menggunakannya untuk menghubungkan ke instans DB.
Kode ini terhubung ke instans DB MariaDB MySQL.
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/go-sql-driver/mysql"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "mysqldb.123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 3306
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authenticationToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Kode ini terhubung ke instans DB PostgreSQL.
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/lib/pq"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 5432
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authenticationToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Jika Anda ingin terhubung ke instans DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
## Menghubungkan menggunakan otentikasi IAM dan V1. AWS SDK untuk Go
Anda dapat terhubung ke instans DB menggunakan otentikasi IAM dan V1 AWS SDK untuk Go
Contoh kode berikut ini menunjukkan cara membuat token autentikasi, lalu menggunakannya untuk menghubungkan ke instans DB.
Kode ini terhubung ke instans DB MariaDB MySQL.
```
package main
import (
"database/sql"
"fmt"
"log"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/go-sql-driver/mysql"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "mysqldb.123456789012.us-east-1.rds.amazonaws.com"
dbPort := 3306
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Kode ini terhubung ke instans DB PostgreSQL.
```
package main
import (
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/lib/pq"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
dbPort := 5432
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Jika Anda ingin terhubung ke instans DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Java
Anda dapat terhubung ke RDS untuk MariaDB, MySQL, atau PostgreSQL DB PostgreSQL DB cluster dengan seperti yang dijelaskan berikut. AWS SDK untuk Java
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke instans DB menggunakan autentikasi IAM:
+ [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Menyiapkan AWS SDK for Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
Untuk contoh tentang cara menggunakan SDK for Java 2.x, lihat [contoh Amazon RDS menggunakan SDK for Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html) 2.x. Anda juga dapat menggunakan AWS Advanced JDBC Wrapper, lihat Dokumentasi [AWS Advanced JDBC](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md) Wrapper.
**Topics**
+ [Membuat token autentikasi IAM](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [Membuat token autentikasi IAM secara manual](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [Menghubungkan ke instans DB](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)
## Membuat token autentikasi IAM
Jika Anda menulis program menggunakan AWS SDK untuk Java, Anda bisa mendapatkan token otentikasi yang ditandatangani menggunakan `RdsIamAuthTokenGenerator` kelas. Menggunakan kelas ini mengharuskan Anda memberikan AWS kredensil. Untuk melakukan ini, Anda membuat instance dari `DefaultAWSCredentialsProviderChain` kelas. `DefaultAWSCredentialsProviderChain`menggunakan kunci AWS akses pertama dan kunci rahasia yang ditemukan di [rantai penyedia kredensi default](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default). Untuk informasi selengkapnya tentang kunci akses AWS , lihat [Mengelola kunci akses untuk pengguna](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir instans DB untuk menghasilkan token autentikasi.
Setelah membuat instans `RdsIamAuthTokenGenerator`, Anda dapat memanggil metode `getAuthToken` untuk mendapatkan token yang ditandatangani. Berikan Wilayah AWS , nama host, nomor port, dan nama pengguna. Contoh kode berikut menunjukkan cara melakukannya.
```
package com.amazonaws.codesamples;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
public class GenerateRDSAuthToken {
public static void main(String[] args) {
String region = "us-west-2";
String hostname = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
System.out.println(generateAuthToken(region, hostname, port, username));
}
static String generateAuthToken(String region, String hostName, String port, String username) {
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new DefaultAWSCredentialsProviderChain())
.region(region)
.build();
String authToken = generator.getAuthToken(
GetIamAuthTokenRequest.builder()
.hostname(hostName)
.port(Integer.parseInt(port))
.userName(username)
.build());
return authToken;
}
}
```
## Membuat token autentikasi IAM secara manual
Di Java, cara termudah untuk menghasilkan token autentikasi adalah dengan menggunakan `RdsIamAuthTokenGenerator`. Kelas ini membuat token otentikasi untuk Anda, dan kemudian menandatanganinya menggunakan AWS tanda tangan versi 4. Untuk informasi selengkapnya, lihat [Proses penandatanganan Signature versi 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) dalam *Referensi Umum AWS.*
Namun, Anda juga dapat membuat dan menandatangani token autentikasi secara manual, seperti ditunjukkan dalam contoh kode berikut.
```
package com.amazonaws.codesamples;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.SigningAlgorithm;
import com.amazonaws.util.BinaryUtils;
import org.apache.commons.lang3.StringUtils;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SortedMap;
import java.util.TreeMap;
import static com.amazonaws.auth.internal.SignerConstants.AWS4_TERMINATOR;
import static com.amazonaws.util.StringUtils.UTF8;
public class CreateRDSAuthTokenManually {
public static String httpMethod = "GET";
public static String action = "connect";
public static String canonicalURIParameter = "/";
public static SortedMap canonicalQueryParameters = new TreeMap();
public static String payload = StringUtils.EMPTY;
public static String signedHeader = "host";
public static String algorithm = "AWS4-HMAC-SHA256";
public static String serviceName = "rds-db";
public static String requestWithoutSignature;
public static void main(String[] args) throws Exception {
String region = "us-west-2";
String instanceName = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
Date now = new Date();
String date = new SimpleDateFormat("yyyyMMdd").format(now);
String dateTimeStamp = new SimpleDateFormat("yyyyMMdd'T'HHmmss'Z'").format(now);
DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
String awsAccessKey = creds.getCredentials().getAWSAccessKeyId();
String awsSecretKey = creds.getCredentials().getAWSSecretKey();
String expiryMinutes = "900";
System.out.println("Step 1: Create a canonical request:");
String canonicalString = createCanonicalString(username, awsAccessKey, date, dateTimeStamp, region, expiryMinutes, instanceName, port);
System.out.println(canonicalString);
System.out.println();
System.out.println("Step 2: Create a string to sign:");
String stringToSign = createStringToSign(dateTimeStamp, canonicalString, awsAccessKey, date, region);
System.out.println(stringToSign);
System.out.println();
System.out.println("Step 3: Calculate the signature:");
String signature = BinaryUtils.toHex(calculateSignature(stringToSign, newSigningKey(awsSecretKey, date, region, serviceName)));
System.out.println(signature);
System.out.println();
System.out.println("Step 4: Add the signing info to the request");
System.out.println(appendSignature(signature));
System.out.println();
}
//Step 1: Create a canonical request date should be in format YYYYMMDD and dateTime should be in format YYYYMMDDTHHMMSSZ
public static String createCanonicalString(String user, String accessKey, String date, String dateTime, String region, String expiryPeriod, String hostName, String port) throws Exception {
canonicalQueryParameters.put("Action", action);
canonicalQueryParameters.put("DBUser", user);
canonicalQueryParameters.put("X-Amz-Algorithm", "AWS4-HMAC-SHA256");
canonicalQueryParameters.put("X-Amz-Credential", accessKey + "%2F" + date + "%2F" + region + "%2F" + serviceName + "%2Faws4_request");
canonicalQueryParameters.put("X-Amz-Date", dateTime);
canonicalQueryParameters.put("X-Amz-Expires", expiryPeriod);
canonicalQueryParameters.put("X-Amz-SignedHeaders", signedHeader);
String canonicalQueryString = "";
while(!canonicalQueryParameters.isEmpty()) {
String currentQueryParameter = canonicalQueryParameters.firstKey();
String currentQueryParameterValue = canonicalQueryParameters.remove(currentQueryParameter);
canonicalQueryString = canonicalQueryString + currentQueryParameter + "=" + currentQueryParameterValue;
if (!currentQueryParameter.equals("X-Amz-SignedHeaders")) {
canonicalQueryString += "&";
}
}
String canonicalHeaders = "host:" + hostName + ":" + port + '\n';
requestWithoutSignature = hostName + ":" + port + "/?" + canonicalQueryString;
String hashedPayload = BinaryUtils.toHex(hash(payload));
return httpMethod + '\n' + canonicalURIParameter + '\n' + canonicalQueryString + '\n' + canonicalHeaders + '\n' + signedHeader + '\n' + hashedPayload;
}
//Step 2: Create a string to sign using sig v4
public static String createStringToSign(String dateTime, String canonicalRequest, String accessKey, String date, String region) throws Exception {
String credentialScope = date + "/" + region + "/" + serviceName + "/aws4_request";
return algorithm + '\n' + dateTime + '\n' + credentialScope + '\n' + BinaryUtils.toHex(hash(canonicalRequest));
}
//Step 3: Calculate signature
/**
* Step 3 of the &AWS; Signature version 4 calculation. It involves deriving
* the signing key and computing the signature. Refer to
* http://docs.aws.amazon
* .com/general/latest/gr/sigv4-calculate-signature.html
*/
public static byte[] calculateSignature(String stringToSign,
byte[] signingKey) {
return sign(stringToSign.getBytes(Charset.forName("UTF-8")), signingKey,
SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(byte[] data, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
Mac mac = algorithm.getMac();
mac.init(new SecretKeySpec(key, algorithm.toString()));
return mac.doFinal(data);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
public static byte[] newSigningKey(String secretKey,
String dateStamp, String regionName, String serviceName) {
byte[] kSecret = ("AWS4" + secretKey).getBytes(Charset.forName("UTF-8"));
byte[] kDate = sign(dateStamp, kSecret, SigningAlgorithm.HmacSHA256);
byte[] kRegion = sign(regionName, kDate, SigningAlgorithm.HmacSHA256);
byte[] kService = sign(serviceName, kRegion,
SigningAlgorithm.HmacSHA256);
return sign(AWS4_TERMINATOR, kService, SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(String stringData, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
byte[] data = stringData.getBytes(UTF8);
return sign(data, key, algorithm);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
//Step 4: append the signature
public static String appendSignature(String signature) {
return requestWithoutSignature + "&X-Amz-Signature=" + signature;
}
public static byte[] hash(String s) throws Exception {
try {
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(s.getBytes(UTF8));
return md.digest();
} catch (Exception e) {
throw new SdkClientException(
"Unable to compute hash while signing request: "
+ e.getMessage(), e);
}
}
}
```
## Menghubungkan ke instans DB
Contoh kode berikut menunjukkan cara membuat token autentikasi, lalu menggunakannya untuk menghubungkan ke instans yang menjalankan MariaDB atau MySQL.
Untuk menjalankan contoh kode ini, Anda memerlukan [AWS SDK untuk Java](https://aws.amazon.com/sdk-for-java/), ditemukan di AWS situs. Selain itu, Anda memerlukan hal berikut:
+ MySQL Connector/J. Contoh kode ini diuji dengan `mysql-connector-java-5.1.33-bin.jar`.
+ Sertifikat perantara untuk Amazon RDS Aurora yang khusus untuk AWS suatu Wilayah. (Untuk informasi selengkapnya, lihat [](UsingWithRDS.SSL.md).) Saat runtime, pemuat kelas mencari sertifikat di direktori yang sama seperti contoh kode Java ini, sehingga pemuat kelas dapat menemukannya.
+ Ubah nilai variabel berikut sesuai kebutuhan:
+ `RDS_INSTANCE_HOSTNAME` – Nama host instans DB yang ingin Anda akses.
+ `RDS_INSTANCE_PORT` – Nomor port yang digunakan untuk menghubungkan ke instans DB PostgreSQL Anda.
+ `REGION_NAME`— AWS Wilayah tempat instans DB berjalan.
+ `DB_USER` – Akun basis data yang ingin Anda akses.
+ `SSL_CERTIFICATE`— Sertifikat SSL untuk Amazon RDS yang khusus untuk suatu Wilayah. AWS
Untuk mengunduh sertifikat untuk Wilayah AWS Anda, lihat [](UsingWithRDS.SSL.md). Tempatkan sertifikat SSL di direktori yang sama dengan file program Java ini, sehingga pemuat kelas dapat menemukan sertifikat saat runtime.
Contoh kode ini memperoleh AWS kredensil dari rantai penyedia [kredensi default](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default).
**catatan**
Tentukan kata sandi untuk `DEFAULT_KEY_STORE_PASSWORD` selain prompt yang ditampilkan di sini sebagai praktik terbaik keamanan.
```
package com.amazonaws.samples;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;
import java.net.URL;
public class IAMDatabaseAuthenticationTester {
//&AWS; Credentials of the IAM user with policy enabling IAM Database Authenticated access to the db by the db user.
private static final DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
private static final String AWS_ACCESS_KEY = creds.getCredentials().getAWSAccessKeyId();
private static final String AWS_SECRET_KEY = creds.getCredentials().getAWSSecretKey();
//Configuration parameters for the generation of the IAM Database Authentication token
private static final String RDS_INSTANCE_HOSTNAME = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
private static final int RDS_INSTANCE_PORT = 3306;
private static final String REGION_NAME = "us-west-2";
private static final String DB_USER = "jane_doe";
private static final String JDBC_URL = "jdbc:mysql://" + RDS_INSTANCE_HOSTNAME + ":" + RDS_INSTANCE_PORT;
private static final String SSL_CERTIFICATE = "rds-ca-2019-us-west-2.pem";
private static final String KEY_STORE_TYPE = "JKS";
private static final String KEY_STORE_PROVIDER = "SUN";
private static final String KEY_STORE_FILE_PREFIX = "sys-connect-via-ssl-test-cacerts";
private static final String KEY_STORE_FILE_SUFFIX = ".jks";
private static final String DEFAULT_KEY_STORE_PASSWORD = "changeit";
public static void main(String[] args) throws Exception {
//get the connection
Connection connection = getDBConnectionUsingIam();
//verify the connection is successful
Statement stmt= connection.createStatement();
ResultSet rs=stmt.executeQuery("SELECT 'Success!' FROM DUAL;");
while (rs.next()) {
String id = rs.getString(1);
System.out.println(id); //Should print "Success!"
}
//close the connection
stmt.close();
connection.close();
clearSslProperties();
}
/**
* This method returns a connection to the db instance authenticated using IAM Database Authentication
* @return
* @throws Exception
*/
private static Connection getDBConnectionUsingIam() throws Exception {
setSslProperties();
return DriverManager.getConnection(JDBC_URL, setMySqlConnectionProperties());
}
/**
* This method sets the mysql connection properties which includes the IAM Database Authentication token
* as the password. It also specifies that SSL verification is required.
* @return
*/
private static Properties setMySqlConnectionProperties() {
Properties mysqlConnectionProperties = new Properties();
mysqlConnectionProperties.setProperty("verifyServerCertificate","true");
mysqlConnectionProperties.setProperty("useSSL", "true");
mysqlConnectionProperties.setProperty("user",DB_USER);
mysqlConnectionProperties.setProperty("password",generateAuthToken());
return mysqlConnectionProperties;
}
/**
* This method generates the IAM Auth Token.
* An example IAM Auth Token would look like follows:
* btusi123---cmz7kenwo2ye---rds---cn-north-1.amazonaws.com.rproxy.goskope.com.cn:3306/?Action=connect&DBUser=iamtestuser&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20171003T010726Z&X-Amz-SignedHeaders=host&X-Amz-Expires=899&X-Amz-Credential=AKIAPFXHGVDI5RNFO4AQ%2F20171003%2Fcn-north-1%2Frds-db%2Faws4_request&X-Amz-Signature=f9f45ef96c1f770cdad11a53e33ffa4c3730bc03fdee820cfdf1322eed15483b
* @return
*/
private static String generateAuthToken() {
BasicAWSCredentials awsCredentials = new BasicAWSCredentials(AWS_ACCESS_KEY, AWS_SECRET_KEY);
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new AWSStaticCredentialsProvider(awsCredentials)).region(REGION_NAME).build();
return generator.getAuthToken(GetIamAuthTokenRequest.builder()
.hostname(RDS_INSTANCE_HOSTNAME).port(RDS_INSTANCE_PORT).userName(DB_USER).build());
}
/**
* This method sets the SSL properties which specify the key store file, its type and password:
* @throws Exception
*/
private static void setSslProperties() throws Exception {
System.setProperty("javax.net.ssl.trustStore", createKeyStoreFile());
System.setProperty("javax.net.ssl.trustStoreType", KEY_STORE_TYPE);
System.setProperty("javax.net.ssl.trustStorePassword", DEFAULT_KEY_STORE_PASSWORD);
}
/**
* This method returns the path of the Key Store File needed for the SSL verification during the IAM Database Authentication to
* the db instance.
* @return
* @throws Exception
*/
private static String createKeyStoreFile() throws Exception {
return createKeyStoreFile(createCertificate()).getPath();
}
/**
* This method generates the SSL certificate
* @return
* @throws Exception
*/
private static X509Certificate createCertificate() throws Exception {
CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
URL url = new File(SSL_CERTIFICATE).toURI().toURL();
if (url == null) {
throw new Exception();
}
try (InputStream certInputStream = url.openStream()) {
return (X509Certificate) certFactory.generateCertificate(certInputStream);
}
}
/**
* This method creates the Key Store File
* @param rootX509Certificate - the SSL certificate to be stored in the KeyStore
* @return
* @throws Exception
*/
private static File createKeyStoreFile(X509Certificate rootX509Certificate) throws Exception {
File keyStoreFile = File.createTempFile(KEY_STORE_FILE_PREFIX, KEY_STORE_FILE_SUFFIX);
try (FileOutputStream fos = new FileOutputStream(keyStoreFile.getPath())) {
KeyStore ks = KeyStore.getInstance(KEY_STORE_TYPE, KEY_STORE_PROVIDER);
ks.load(null);
ks.setCertificateEntry("rootCaCertificate", rootX509Certificate);
ks.store(fos, DEFAULT_KEY_STORE_PASSWORD.toCharArray());
}
return keyStoreFile;
}
/**
* This method clears the SSL properties.
* @throws Exception
*/
private static void clearSslProperties() throws Exception {
System.clearProperty("javax.net.ssl.trustStore");
System.clearProperty("javax.net.ssl.trustStoreType");
System.clearProperty("javax.net.ssl.trustStorePassword");
}
}
```
Jika Anda ingin terhubung ke instans DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke instans DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Python (Boto3)
Anda dapat terhubung ke RDS untuk MariaDB, MySQL, atau PostgreSQL DB PostgreSQL DB cluster dengan seperti yang dijelaskan berikut. AWS SDK untuk Python (Boto3)
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke instans DB menggunakan autentikasi IAM:
+ [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Membuat dan menggunakan kebijakan IAM untuk akses basis data IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
Selain itu, pastikan pustaka yang diimpor dalam kode sampel ada di sistem Anda.
**Contoh**
Contoh kode ini menggunakan profil untuk kredensial bersama. Untuk informasi tentang kredensi yang menentukan, lihat [Kredensial](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) dalam dokumentasi. AWS SDK untuk Python (Boto3)
Contoh kode berikut ini menunjukkan cara membuat token autentikasi, lalu menggunakannya untuk menghubungkan ke instans DB.
Untuk menjalankan contoh kode ini, Anda memerlukan [AWS SDK untuk Python (Boto3)](https://aws.amazon.com/sdk-for-python/), ditemukan di AWS situs.
Ubah nilai variabel berikut sesuai kebutuhan:
+ `ENDPOINT` – Titik akhir instans DB yang ingin Anda akses
+ `PORT` – Nomor port yang digunakan untuk menghubungkan ke instans DB Anda
+ `USER` – Akun basis data yang ingin Anda akses
+ `REGION`— AWS Wilayah tempat instans DB berjalan
+ `DBNAME` – Basis data yang ingin Anda akses
+ `SSLCERTIFICATE` – Jalur lengkap ke sertifikat SSL untuk Amazon RDS
Untuk `ssl_ca`, tentukan sertifikat SSL. Untuk mengunduh sertifikat SSL, lihat [](UsingWithRDS.SSL.md).
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir instans DB untuk menghasilkan token autentikasi.
Kode ini terhubung ke instans DB MariaDB MySQL.
Sebelum menjalankan kode ini, instal driver PyMy SQL dengan mengikuti instruksi dalam Indeks [Paket Python](https://pypi.org/project/PyMySQL/).
```
import pymysql
import sys
import boto3
import os
ENDPOINT="mysqldb.123456789012.us-east-1.rds.amazonaws.com"
PORT="3306"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
os.environ['LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN'] = '1'
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='default')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = pymysql.connect(auth_plugin_map={'mysql_clear_password':None},host=ENDPOINT, user=USER, password=token, port=PORT, database=DBNAME, ssl_ca='SSLCERTIFICATE', ssl_verify_identity=True, ssl_verify_cert=True)
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
Kode ini terhubung ke instans DB PostgreSQL.
Sebelum menjalankan kode ini, instal `psycopg2` dengan mengikuti petunjuk dalam [dokumentasi Psycopg](https://pypi.org/project/psycopg2/).
```
import psycopg2
import sys
import boto3
import os
ENDPOINT="postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
PORT="5432"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='RDSCreds')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = psycopg2.connect(host=ENDPOINT, port=PORT, database=DBNAME, user=USER, password=token, sslrootcert="SSLCERTIFICATE")
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
Jika Anda ingin terhubung ke instans DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Pemecahan masalah untuk otentikasi IAM DB
Berikut ini, Anda dapat menemukan ide pemecahan masalah untuk beberapa masalah otentikasi IAM DB umum dan informasi tentang CloudWatch log dan metrik untuk otentikasi IAM DB.
## Mengekspor log kesalahan otentikasi IAM DB ke Log CloudWatch
Log kesalahan otentikasi IAM DB disimpan di host database, dan Anda dapat mengekspor log ini ke akun CloudWatch Log Anda. Gunakan log dan metode remediasi di halaman ini untuk memecahkan masalah autentikasi IAM DB.
Anda dapat mengaktifkan ekspor log ke CloudWatch Log dari konsol AWS CLI, dan RDS API. Untuk petunjuk konsol, lihat[Menerbitkan log database ke Amazon CloudWatch Logs](USER_LogAccess.Procedural.UploadtoCloudWatch.md).
Untuk mengekspor log kesalahan autentikasi IAM DB Anda ke CloudWatch Log saat membuat dari AWS CLI, gunakan perintah berikut:
```
aws rds create-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--db-instance-class db.t3.large \
--allocated-storage 50 \
--engine postgres \
--engine-version 16 \
--port 5432 \
--master-username master \
--master-user-password password \
--publicly-accessible \
--enable-iam-database-authentication \
--enable-cloudwatch-logs-exports=iam-db-auth-error
```
Untuk mengekspor log kesalahan autentikasi IAM DB Anda ke CloudWatch Log saat memodifikasi dari AWS CLI, gunakan perintah berikut:
```
aws rds modify-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["iam-db-auth-error"]}'
```
Untuk memverifikasi apakah Anda mengekspor log otentikasi IAM DB ke CloudWatch Log, periksa apakah `EnabledCloudwatchLogsExports` parameter diatur ke `iam-db-auth-error` dalam output untuk perintah tersebut. `describe-db-instances`
```
aws rds describe-db-instances --region us-east-1 --db-instance-identifier mydbinstance
...
"EnabledCloudwatchLogsExports": [
"iam-db-auth-error"
],
...
```
## Metrik otentikasi CloudWatch IAM DB
Amazon RDS Aurora memberikan metrik waktu nyaris nyata tentang autentikasi IAM DB ke akun Amazon Anda. CloudWatch Tabel berikut mencantumkan metrik autentikasi IAM DB yang tersedia menggunakan: CloudWatch
| Metrik | Deskripsi |
| --- | --- |
| `IamDbAuthConnectionRequests` | Jumlah total permintaan koneksi yang dibuat dengan otentikasi IAM DB. |
| `IamDbAuthConnectionSuccess` | Jumlah total permintaan otentikasi IAM DB yang berhasil. |
| `IamDbAuthConnectionFailure` | Jumlah total permintaan otentikasi IAM DB yang gagal. |
| `IamDbAuthConnectionFailureInvalidToken` | Jumlah total permintaan otentikasi IAM DB yang gagal karena token tidak valid. |
| `IamDbAuthConnectionFailureInsufficientPermissions` | Jumlah total permintaan otentikasi IAM DB yang gagal karena kebijakan atau izin yang salah. |
| `IamDbAuthConnectionFailureThrottling` | Jumlah total permintaan otentikasi IAM DB yang gagal karena pelambatan otentikasi IAM DB. |
| `IamDbAuthConnectionFailureServerError` | Jumlah total permintaan otentikasi IAM DB yang gagal karena kesalahan server internal dalam fitur otentikasi IAM DB. |
## Masalah dan solusi umum
Anda mungkin mengalami masalah berikut saat menggunakan keaslian IAM DB. Gunakan langkah-langkah remediasi dalam tabel untuk menyelesaikan masalah:
| Kesalahan | Metrik | Penyebab | Solusi |
| --- | --- | --- | --- |
| `[ERROR] Failed to authenticate the connection request for user db_user because the provided token is malformed or otherwise invalid. (Status Code: 400, Error Code: InvalidToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Token autentiasi IAM DB dalam permintaan koneksi bukan token Sigv4a yang valid, atau tidak diformat dengan benar. | Periksa strategi pembuatan token Anda di aplikasi Anda. Dalam beberapa kasus, pastikan Anda meneruskan token dengan format yang valid. Memangkas token (atau pemformatan string yang salah) akan membuat token tidak valid. |
| `[ERROR] Failed to authenticate the connection request for user db_user because the token age is longer than 15 minutes. (Status Code: 400, Error Code:ExpiredToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Token otentikasi IAM DB telah kedaluwarsa. Token hanya berlaku selama 15 menit. | Periksa logika penggunaan kembali token caching and/or token Anda di aplikasi Anda. Anda tidak boleh menggunakan kembali token yang lebih tua dari 15 menit. |
| `[ERROR] Failed to authorize the connection request for user db_user because the IAM policy assumed by the caller 'arn:aws:sts::123456789012:assumed-role/ / ' is not authorized to perform `rds-db:connect` on the DB instance. (Status Code: 403, Error Code:NotAuthorized)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInsufficientPermissions` | Kesalahan ini mungkin terjadi karena alasan berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.Troubleshooting.html) | Verifikasi bahwa and/or kebijakan peran IAM yang Anda asumsikan dalam aplikasi Anda. Pastikan Anda mengasumsikan kebijakan yang sama untuk menghasilkan token untuk terhubung ke DB. |
| `[ERROR] Failed to authorize the connection request for user db_user due to IAM DB authentication throttling. (Status Code: 429, Error Code: ThrottlingException)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Anda membuat terlalu banyak permintaan koneksi ke DB Anda dalam waktu singkat. Batas pelambatan otentikasi IAM DB adalah 200 koneksi per detik. | Kurangi tingkat membangun koneksi baru dengan otentikasi IAM. Pertimbangkan untuk menerapkan penyatuan koneksi menggunakan RDS Proxy untuk menggunakan kembali koneksi yang sudah ada di aplikasi Anda. |
| `[ERROR] Failed to authorize the connection request for user db_user due to an internal IAM DB authentication error. (Status Code: 500, Error Code: InternalError)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Ada kesalahan internal saat mengotorisasi koneksi DB dengan otentikasi IAM DB. | Jangkau https://aws.amazon.com/premiumsupport/ untuk menyelidiki masalah ini. |