Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memulai dengan RDS Proxy
Gunakan informasi di halaman berikut untuk mengatur [Proksi Amazon RDS Aurora](rds-proxy.md) dan mengelola serta mengatur opsi keamanan terkait. Opsi keamanan mengontrol siapa yang dapat mengakses setiap proxy dan bagaimana setiap proxy terhubung ke instans DB.
Jika Anda baru mengenal RDS Proxy, sebaiknya ikuti halaman sesuai urutan yang kami sajikan.
**Topics**
+ [Menyiapkan prasyarat jaringan untuk RDS Proxy](rds-proxy-network-prereqs.md)
+ [Menyiapkan kredensil database untuk RDS Proxy](rds-proxy-secrets-arns.md)
+ [Mengkonfigurasi otentikasi IAM untuk RDS Proxy](rds-proxy-iam-setup.md)
+ [Membuat proxy untuk Amazon RDS](rds-proxy-creating.md)
+ [Melihat proxy](rds-proxy-viewing.md)
+ [Terhubung ke basis data melalui Proksi RDS](rds-proxy-connecting.md)
# Menyiapkan prasyarat jaringan untuk RDS Proxy
Menggunakan Proksi RDS mengharuskan Anda memiliki cloud privat virtual (VPC) umum antara instans DB RDS dan Proksi RDS. VPC ini harus memiliki minimal dua subnet yang berada di Zona Ketersediaan yang berbeda. Akun Anda dapat memiliki subnet ini atau membagikannya dengan akun lain. Untuk informasi tentang berbagi VPC, lihat [Bekerja dengan](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-sharing.html) berbagi. VPCs
Untuk IPv6 dukungan, konfigurasi jaringan tambahan diperlukan:
+ **IPv6 Jenis jaringan endpoint** — VPC dan subnet Anda harus dikonfigurasi untuk mendukung. IPv6 Ini termasuk memiliki blok IPv6 CIDR yang ditetapkan ke VPC dan subnet Anda.
+ **Tipe jaringan endpoint dual-stack** — VPC dan subnet Anda harus mendukung keduanya dan pengalamatan. IPv4 IPv6
+ **IPv6 jenis jaringan koneksi target** — Database Anda harus dikonfigurasi untuk mode dual-stack untuk mendukung IPv6 koneksi dari proxy.
Sumber daya aplikasi klien seperti Amazon EC2, Lambda, atau Amazon ECS bisa berada di VPC yang sama dengan proksi. Atau sumber daya ini bisa berada di VPC terpisah dari proksi. Jika Anda berhasil terhubung ke instans DB RDS apa pun, berarti Anda sudah memiliki sumber daya jaringan yang diperlukan.
**Topics**
+ [Mendapatkan informasi tentang subnet Anda](#rds-proxy-network-prereqs.subnet-info)
+ [Perencanaan untuk kapasitas alamat IP](#rds-proxy-network-prereqs.plan-ip-address)
## Mendapatkan informasi tentang subnet Anda
Untuk membuat proxy, Anda harus menyediakan subnet dan VPC tempat proxy beroperasi di dalamnya. Contoh Linux berikut menunjukkan AWS CLI perintah yang memeriksa VPCs dan subnet yang dimiliki oleh Anda Akun AWS. Secara khusus, Anda meneruskan subnet IDs sebagai parameter saat Anda membuat proxy menggunakan CLI.
```
aws ec2 describe-vpcs
aws ec2 describe-internet-gateways
aws ec2 describe-subnets --query '*[].[VpcId,SubnetId]' --output text | sort
```
Contoh Linux berikut menunjukkan AWS CLI perintah untuk menentukan subnet yang IDs sesuai dengan instance RDS DB tertentu DB cluster. Temukan ID VPC untuk instance DB. Periksa VPC untuk menemukan subnetnya. Contoh Linux berikut menunjukkan caranya.
```
$ #From the DB instance, trace through the DBSubnetGroup and Subnets to find the subnet IDs.
$ aws rds describe-db-instances --db-instance-identifier my_instance_id --query '*[].[DBSubnetGroup]|[0]|[0]|[Subnets]|[0]|[*].SubnetIdentifier' --output text
```
```
subnet_id_1
subnet_id_2
subnet_id_3
...
```
```
$ #From the DB instance, find the VPC.
$ aws rds describe-db-instances --db-instance-identifier my_instance_id --query '*[].[DBSubnetGroup]|[0]|[0].VpcId' --output text
```
```
my_vpc_id
```
```
$ aws ec2 describe-subnets --filters Name=vpc-id,Values=my_vpc_id --query '*[].[SubnetId]' --output text
```
```
subnet_id_1
subnet_id_2
subnet_id_3
subnet_id_4
subnet_id_5
subnet_id_6
```
## Perencanaan untuk kapasitas alamat IP
Proksi RDS secara otomatis menyesuaikan kapasitasnya sesuai kebutuhan berdasarkan ukuran dan jumlah instans DB yang didaftarkan di proksi. Operasi tertentu mungkin juga memerlukan kapasitas proksi tambahan seperti menambah ukuran basis data yang terdaftar atau operasi pemeliharaan Proksi RDS internal. Selama operasi ini, proksi Anda mungkin memerlukan lebih banyak alamat IP untuk menyediakan kapasitas tambahan. Alamat tambahan ini memungkinkan proksi Anda diskalakan tanpa memengaruhi beban kerja Anda. Kurangnya alamat IP kosong di subnet Anda mencegah kenaikan skala proksi. Hal ini dapat menyebabkan latensi kueri yang lebih tinggi atau kegagalan koneksi klien. RDS memberi tahu Anda melalui peristiwa `RDS-EVENT-0243` ketika tidak ada cukup alamat IP kosong di subnet Anda. Untuk informasi tentang peristiwa ini, lihat [Bekerja dengan acara RDS ProxyBekerja dengan acara RDS Proxy](rds-proxy.events.md).
**catatan**
RDS Proxy tidak menggunakan lebih dari 215 alamat IP untuk setiap proxy dalam VPC.
Cadangan jumlah minimum alamat IP gratis berikut di subnet Anda untuk proxy Anda, berdasarkan ukuran kelas instans DB.
| Kelas instans DB | Alamat IP kosong minimum |
| --- | --- |
| db.\$1.xlarge atau lebih kecil | 10 |
| db.\$1.2xlarge | 15 |
| db.\$1.4xlarge | 25 |
| db.\$1.8xlarge | 45 |
| db.\$1.12xlarge | 60 |
| db.\$1.16xlarge | 75 |
| db.\$1.24xlarge | 110 |
Jumlah alamat IP yang direkomendasikan ini adalah perkiraan untuk proksi dengan titik akhir default saja. Proksi dengan titik akhir tambahan atau replika baca mungkin memerlukan lebih banyak alamat IP kosong. Untuk setiap titik akhir tambahan, sebaiknya Anda mencadangkan tiga alamat IP lagi. Untuk setiap replika baca, sebaiknya Anda mencadangkan alamat IP tambahan seperti yang ditentukan dalam tabel berdasarkan ukuran replika baca tersebut.
# Menyiapkan kredensil database untuk RDS Proxy
RDS Proxy di Amazon RDS digunakan AWS Secrets Manager untuk menyimpan dan mengelola kredenal database dengan aman. Alih-alih menyematkan kredensi dalam aplikasi Anda, Anda mengaitkan proxy dengan rahasia Secrets Manager yang berisi detail otentikasi yang diperlukan. Anda dapat membuat rahasia Secrets Manager terpisah untuk setiap akun pengguna basis data yang terhubung ke instans DB RDS.
Atau, Anda dapat mengonfigurasi RDS Proxy untuk menggunakan otentikasi end-to-end IAM, yang menghilangkan kebutuhan untuk menyimpan kredensil database di Secrets Manager. RDS Proxy menggunakan otentikasi IAM untuk keduanya client-to-proxy dan koneksi. proxy-to-database Ini menyediakan solusi otentikasi berbasis IAM terintegrasi penuh yang tidak memerlukan pengelolaan rahasia atau kata sandi. Untuk informasi tentang menambahkan pengguna IAM DB baru, lihat[Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md).
**Topics**
+ [Membuat rahasia untuk digunakan dengan RDS Proxy](#rds-proxy-secrets-create)
## Membuat rahasia untuk digunakan dengan RDS Proxy
Sebelum Anda membuat proxy, Anda harus terlebih dahulu membuat setidaknya satu rahasia yang menyimpan kredensi database Anda.
### Konsol
**Untuk membuat rahasia**
1. Buka konsol Secrets Manager di [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Pilih **Simpan rahasia baru**.
1. Pilih **Kredensial untuk database Amazon RDS**.
1. Masukkan nama pengguna dan kata sandi. Kredensial yang Anda masukkan harus cocok dengan kredensi pengguna database yang ada di database RDS terkait. RDS Proxy menggunakan kredensil ini untuk mengautentikasi dan membangun koneksi ke database atas nama aplikasi.
Jika ada ketidakcocokan, Anda dapat memperbarui rahasia agar sesuai dengan kata sandi database. Sampai Anda memperbarui rahasia, upaya untuk terhubung melalui proxy menggunakan rahasia itu gagal, tetapi koneksi menggunakan rahasia valid lainnya masih berfungsi.
**catatan**
Untuk RDS untuk SQL Server, RDS Proxy memerlukan rahasia case-sensitive di Secrets Manager, terlepas dari pengaturan pengumpulan instans DB. Jika aplikasi Anda mengizinkan nama pengguna dengan kapitalisasi yang berbeda, seperti “Admin” dan “admin,” Anda harus membuat rahasia terpisah untuk masing-masing. RDS Proxy tidak mendukung otentikasi nama pengguna yang tidak peka huruf besar/kecil antara klien dan proxy.
Untuk informasi selengkapnya tentang kolasi di SQL Server, lihat dokumentasi [Microsoft SQL Server](https://docs.microsoft.com/en-us/sql/relational-databases/collations/collation-and-unicode-support?view=sql-server-ver16).
1. Untuk **Database**, pilih database Amazon RDS yang akan diakses rahasia.
1. Isi pengaturan lain untuk rahasia, lalu pilih **Store**. Untuk petunjuk komprehensif, lihat [Membuat AWS Secrets Manager rahasia](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) di *Panduan AWS Secrets Manager Pengguna*.
### AWS CLI
Saat Anda membuat proxy melalui AWS CLI, Anda menentukan Amazon Resource Names (ARNs) dari rahasia terkait. Anda melakukannya untuk semua akun pengguna DB yang dapat diakses proksi. Dalam Konsol Manajemen AWS, Anda memilih rahasia dengan nama deskriptif mereka.
+ Untuk membuat rahasia Secrets Manager untuk digunakan dengan RDS Proxy, gunakan perintah [create-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/create-secret.html):
```
aws secretsmanager create-secret \
--name "secret_name" \
--description "secret_description" \
--region region_name \
--secret-string '{"username":"db_user","password":"db_user_password"}'
```
+ Anda juga dapat membuat kunci khusus untuk mengenkripsi rahasia Secrets Manager Anda. Perintah berikut menciptakan kunci contoh.
```
aws kms create-key --description "test-key" --policy '{
"Id":"kms-policy",
"Version": "2012-10-17",
"Statement":
[
{
"Sid":"Enable IAM User Permissions",
"Effect":"Allow",
"Principal":{"AWS":"arn:aws:iam::account_id:root"},
"Action":"kms:*","Resource":"*"
},
{
"Sid":"Allow access for Key Administrators",
"Effect":"Allow",
"Principal":
{
"AWS":
["$USER_ARN","arn:aws:iam:account_id::role/Admin"]
},
"Action":
[
"kms:Create*",
"kms:Describe*",
"kms:Enable*",
"kms:List*",
"kms:Put*",
"kms:Update*",
"kms:Revoke*",
"kms:Disable*",
"kms:Get*",
"kms:Delete*",
"kms:TagResource",
"kms:UntagResource",
"kms:ScheduleKeyDeletion",
"kms:CancelKeyDeletion"
],
"Resource":"*"
},
{
"Sid":"Allow use of the key",
"Effect":"Allow",
"Principal":{"AWS":"$ROLE_ARN"},
"Action":["kms:Decrypt","kms:DescribeKey"],
"Resource":"*"
}
]
}'
```
Misalnya, perintah berikut membuat rahasia Secrets Manager untuk dua pengguna database:
```
aws secretsmanager create-secret \
--name secret_name_1 --description "db admin user" \
--secret-string '{"username":"admin","password":"choose_your_own_password"}'
aws secretsmanager create-secret \
--name secret_name_2 --description "application user" \
--secret-string '{"username":"app-user","password":"choose_your_own_password"}'
```
Untuk membuat rahasia ini dienkripsi dengan AWS KMS kunci kustom Anda, gunakan perintah berikut:
```
aws secretsmanager create-secret \
--name secret_name_1 --description "db admin user" \
--secret-string '{"username":"admin","password":"choose_your_own_password"}' \
--kms-key-id arn:aws:kms:us-east-2:account_id:key/key_id
aws secretsmanager create-secret \
--name secret_name_2 --description "application user" \
--secret-string '{"username":"app-user","password":"choose_your_own_password"}' \
--kms-key-id arn:aws:kms:us-east-2:account_id:key/key_id
```
Untuk melihat rahasia yang dimiliki oleh AWS akun Anda, gunakan perintah [daftar-rahasia](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/list-secrets.html):
```
aws secretsmanager list-secrets
```
Saat Anda membuat proxy menggunakan CLI, Anda meneruskan Amazon Resource Names (ARNs) dari satu atau beberapa rahasia ke parameter. `--auth` Contoh berikut menunjukkan cara menyiapkan laporan hanya dengan nama dan ARN dari setiap rahasia yang dimiliki oleh akun Anda AWS . Contoh ini menggunakan `--output table` parameter yang tersedia di AWS CLI versi 2. Jika Anda menggunakan AWS CLI versi 1, gunakan `--output text` sebagai gantinya.
```
aws secretsmanager list-secrets --query '*[].[Name,ARN]' --output table
```
Untuk mengonfirmasi bahwa rahasia berisi kredensil yang benar dalam format yang tepat, gunakan perintah. [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) Ganti `your_secret_name` dengan nama pendek rahasia atau ARN.
```
aws secretsmanager get-secret-value --secret-id your_secret_name
```
Outputnya berisi garis dengan nilai yang dikodekan JSON mirip dengan yang berikut ini:
```
...
"SecretString": "{\"username\":\"your_username\",\"password\":\"your_password\"}",
...
```
# Mengkonfigurasi otentikasi IAM untuk RDS Proxy
Untuk menyiapkan autentikasi AWS Identity and Access Management (IAM) untuk Proxy RDS di Amazon RDS, buat dan konfigurasikan kebijakan IAM yang memberikan izin yang diperlukan.
Topik ini menyediakan langkah-langkah untuk mengonfigurasi autentikasi IAM untuk RDS Proxy, termasuk membuat kebijakan IAM yang diperlukan dan melampirkannya ke peran IAM.
**Tip**
Prosedur ini hanya diperlukan jika Anda ingin membuat peran IAM Anda sendiri. Jika tidak, RDS dapat secara otomatis membuat peran yang diperlukan saat Anda mengatur proxy, sehingga Anda dapat melewati langkah-langkah ini.
## Prasyarat
Sebelum Anda mengatur autentikasi IAM untuk RDS Proxy, pastikan Anda memiliki yang berikut:
+ **AWS Secrets Manager**— Setidaknya satu rahasia tersimpan yang berisi kredensi database. Untuk instruksi untuk membuat rahasia, lihat[Menyiapkan kredensil database untuk RDS Proxy](rds-proxy-secrets-arns.md).
Ini tidak diperlukan jika Anda menggunakan otentikasi end-to-end IAM.
+ **Izin IAM — Peran** IAM atau pengguna dengan izin untuk membuat dan mengelola kebijakan, peran, dan rahasia IAM. AWS Secrets Manager
## Membuat kebijakan IAM untuk autentikasi end-to-end IAM
Saat menggunakan autentikasi end-to-end IAM, RDS Proxy terhubung ke database Anda menggunakan autentikasi IAM alih-alih mengambil kredensi dari Secrets Manager. Ini memerlukan konfigurasi peran IAM Anda dengan `rds-db:connect` izin untuk akun database yang ingin Anda gunakan dengan proxy.
Untuk mengautentikasi Proxy RDS Anda ke database menggunakan IAM, buat peran IAM dengan kebijakan yang memberikan izin koneksi database yang diperlukan.
### Konsol
**Untuk membuat peran untuk otentikasi end-to-end IAM dengan proxy Anda**
1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Buat kebijakan izin untuk peran tersebut. Untuk langkah umum, lihat [Membuat kebijakan IAM (konsol)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html).
Tempelkan kebijakan ini ke editor JSON dan buat perubahan berikut:
+ Ganti ID akun Anda sendiri.
+ Gantikan `us-east-2` dengan tempat proxy harus berada.
+ Gantikan sumber daya database IDs dan nama pengguna dengan yang ingin Anda gunakan. Format ID sumber daya berbeda antara instance RDS dan. Aurora clusters
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "rds-db:connect",
"Resource": [
"arn:aws:rds-db:us-east-2:account_id:dbuser:db_instance_resource_id/db_user_name_1",
"arn:aws:rds-db:us-east-2:account_id:dbuser:db_instance_resource_id/db_user_name_2"
]
}
]
}
```
1. Buat peran dan lampirkan kebijakan izin padanya. Untuk langkah umum, lihat [Membuat peran untuk mendelegasikan izin ke layanan](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). AWS
Untuk **jenis entitas Tepercaya**, pilih **AWS layanan**. Di bawah **Kasus penggunaan**, pilih **RDS** dan pilih **RDS - Tambahkan Peran ke Database** untuk kasus penggunaan.
1. Untuk **kebijakan Izin**, pilih kebijakan yang Anda buat.
1. Untuk **Pilih entitas tepercaya**, masukkan kebijakan kepercayaan berikut untuk peran tersebut:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
### AWS CLI
Untuk membuat peran menggunakan AWS CLI, kirim permintaan berikut:
```
aws iam create-role \
--role-name my_e2e_iam_role_name \
--assume-role-policy-document '{"Version":"2012-10-17", "Statement":[{"Effect":"Allow","Principal":{"Service":["rds.amazonaws.com"]},"Action":"sts:AssumeRole"}]}'
```
Kemudian, lampirkan kebijakan ke peran:
```
aws iam put-role-policy \
--role-name my_e2e_iam_role_name \
--policy-name e2e_iam_db_connect_policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "rds-db:connect",
"Resource": [
"arn:aws:rds-db:us-east-2:account_id:dbuser:db_instance_resource_id/db_user_name_1",
"arn:aws:rds-db:us-east-2:account_id:dbuser:db_instance_resource_id/db_user_name_2"
]
}
]
}'
```
Dengan peran IAM dan izin yang dikonfigurasi untuk autentikasi end-to-end IAM, Anda sekarang dapat membuat proxy dengan set to. `DefaultAuthScheme` `IAM_AUTH` Proxy ini langsung mengautentikasi ke database menggunakan IAM tanpa memerlukan rahasia Secrets Manager. Untuk petunjuk, lihat [Membuat proxy untuk Amazon RDS ](rds-proxy-creating.md).
Saat menggunakan autentikasi end-to-end IAM, pastikan bahwa pengguna database Anda dikonfigurasi untuk autentikasi IAM seperti yang dijelaskan dalam. [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
## Membuat kebijakan IAM untuk akses Secrets Manager
Untuk mengizinkan RDS Proxy mengambil kredenal database dari Secrets Manager, buat peran IAM dengan kebijakan yang memberikan izin yang diperlukan.
## Konsol
**Untuk membuat peran untuk mengakses rahasia Anda untuk digunakan dengan proxy Anda**
1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Buat kebijakan izin untuk peran tersebut. Untuk langkah umum, lihat [Membuat kebijakan IAM (konsol)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html).
Tempelkan kebijakan ini ke editor JSON dan buat perubahan berikut:
+ Ganti ID akun Anda sendiri.
+ Gantikan `us-east-2` dengan Wilayah tempat proxy akan berada.
+ Ganti nama rahasia dengan yang Anda buat. Untuk informasi selengkapnya, lihat [Menentukan kunci KMS dalam pernyataan kebijakan IAM](https://docs.aws.amazon.com/kms/latest/developerguide/cmks-in-iam-policies.html).
+ Ganti ID kunci KMS dengan yang Anda gunakan untuk mengenkripsi rahasia Secrets Manager, baik kunci default atau kunci Anda sendiri.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": [
"arn:aws:secretsmanager:us-east-2:111122223333:secret:secret_name_1",
"arn:aws:secretsmanager:us-east-2:111122223333:secret:secret_name_2"
]
},
{
"Effect": "Allow",
"Action": "kms:Decrypt",
"Resource": "arn:aws:kms:us-east-2:111122223333:key/key_id",
"Condition": {
"StringEquals": {
"kms:ViaService": "secretsmanager.us-east-2.amazonaws.com"
}
}
}
]
}
```
------
1. Buat peran dan lampirkan kebijakan izin padanya. Untuk langkah umum, lihat [Membuat peran untuk mendelegasikan izin ke layanan](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). AWS
Untuk **jenis entitas Tepercaya**, pilih **AWS layanan**. Di bawah **Kasus penggunaan**, pilih **RDS** dan pilih **RDS - Tambahkan Peran ke Database** untuk kasus penggunaan.
1. Untuk **kebijakan Izin**, pilih kebijakan yang Anda buat.
1. Untuk **Pilih entitas tepercaya**, masukkan kebijakan kepercayaan berikut untuk peran tersebut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
## AWS CLI
Untuk membuat peran menggunakan AWS CLI, kirim permintaan berikut:
```
aws iam create-role \
--role-name my_role_name \
--assume-role-policy-document '{"Version": "2012-10-17", "Statement":[{"Effect":"Allow","Principal":{"Service":["rds.amazonaws.com"]},"Action":"sts:AssumeRole"}]}'
```
Kemudian, lampirkan kebijakan ke peran:
```
aws iam put-role-policy \
--role-name my_role_name \
--policy-name secret_reader_policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": [
"arn:aws:secretsmanager:us-east-2:account_id:secret:secret_name_1",
"arn:aws:secretsmanager:us-east-2:account_id:secret:secret_name_2"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "kms:Decrypt",
"Resource": "arn:aws:kms:us-east-2:account_id:key/key_id",
"Condition": {
"StringEquals": {
"kms:ViaService": "secretsmanager.us-east-2.amazonaws.com"
}
}
}
]
}'
```
Dengan peran dan izin IAM yang dikonfigurasi, Anda sekarang dapat membuat proxy dan mengaitkannya dengan peran ini. Hal ini memungkinkan proxy untuk mengambil kredensi database dengan aman dari AWS Secrets Manager dan mengaktifkan autentikasi IAM untuk aplikasi Anda. Untuk petunjuk, lihat [Membuat proxy untuk Amazon RDS ](rds-proxy-creating.md).
# Membuat proxy untuk Amazon RDS
Anda dapat mengaitkan proksi dengan instans DB RDS for MariaDB, RDS for Microsoft SQL Server, RDS for MySQL, atau RDS for PostgreSQL.
## Konsol
**Untuk membuat proksi**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih **Proksi**.
1. Pilih **Buat proksi**.
1. Konfigurasikan pengaturan berikut untuk proxy Anda.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/rds-proxy-creating.html)
1. Pilih **Buat proksi**.
## AWS CLI
Untuk membuat proxy dengan menggunakan AWS CLI, panggil [create-db-proxy](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-proxy.html)perintah dengan parameter yang diperlukan berikut:
+ `--db-proxy-name`
+ `--engine-family`
+ `--role-arn`
+ `--vpc-subnet-ids`
Nilai `--engine-family` ini bersifat peka huruf besar-kecil.
**Example**
Untuk Linux, macOS, atau Unix:
```
aws rds create-db-proxy \
--db-proxy-name proxy_name \
--engine-family { MYSQL | POSTGRESQL | SQLSERVER } \
--role-arn iam_role \
--vpc-subnet-ids space_separated_list \
[--default-auth-scheme { NONE | IAM_AUTH }] \
[--auth ProxyAuthenticationConfig_JSON_string] \
[--vpc-security-group-ids space_separated_list] \
[--require-tls | --no-require-tls] \
[--idle-client-timeout value] \
[--debug-logging | --no-debug-logging] \
[--endpoint-network-type { IPV4 | IPV6 | DUAL }] \
[--target-connection-network-type { IPV4 | IPV6 }] \
[--tags comma_separated_list]
```
Untuk Windows:
```
aws rds create-db-proxy ^
--db-proxy-name proxy_name ^
--engine-family { MYSQL | POSTGRESQL | SQLSERVER } ^
--role-arn iam_role ^
--vpc-subnet-ids space_separated_list ^
[--default-auth-scheme { NONE | IAM_AUTH }] ^
[--auth ProxyAuthenticationConfig_JSON_string] ^
[--vpc-security-group-ids space_separated_list] ^
[--require-tls | --no-require-tls] ^
[--idle-client-timeout value] ^
[--debug-logging | --no-debug-logging] ^
[--endpoint-network-type { IPV4 | IPV6 | DUAL }] ^
[--target-connection-network-type { IPV4 | IPV6 }] ^
[--tags comma_separated_list]
```
Berikut ini adalah contoh nilai JSON untuk opsi `--auth`. Contoh ini menerapkan jenis otentikasi klien yang berbeda untuk setiap rahasia.
```
[
{
"Description": "proxy description 1",
"AuthScheme": "SECRETS",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789123:secret/1234abcd-12ab-34cd-56ef-1234567890ab",
"IAMAuth": "DISABLED",
"ClientPasswordAuthType": "POSTGRES_SCRAM_SHA_256"
},
{
"Description": "proxy description 2",
"AuthScheme": "SECRETS",
"SecretArn": "arn:aws:secretsmanager:us-west-2:111122223333:secret/1234abcd-12ab-34cd-56ef-1234567890cd",
"IAMAuth": "DISABLED",
"ClientPasswordAuthType": "POSTGRES_MD5"
},
{
"Description": "proxy description 3",
"AuthScheme": "SECRETS",
"SecretArn": "arn:aws:secretsmanager:us-west-2:111122221111:secret/1234abcd-12ab-34cd-56ef-1234567890ef",
"IAMAuth": "REQUIRED"
}
]
```
`--endpoint-network-type`Parameter menentukan versi IP untuk titik akhir proxy yang digunakan klien untuk terhubung ke proxy. Nilai yang valid adalah:
+ `IPV4`— Titik akhir proxy hanya menggunakan IPv4 alamat (default).
+ `IPV6`— Titik akhir proxy hanya menggunakan IPv6 alamat.
+ `DUAL`— Titik akhir proxy mendukung keduanya IPv4 dan IPv6 alamat.
`--target-connection-network-type`Parameter menentukan versi IP yang digunakan proxy untuk terhubung ke database target. Nilai yang valid adalah:
+ `IPV4`— Proxy terhubung ke database menggunakan IPv4 alamat (default).
+ `IPV6`— Proxy terhubung ke database menggunakan IPv6 alamat.
Untuk menggunakan IPv6 atau dual-stack tipe jaringan endpoint, VPC dan subnet Anda harus dikonfigurasi untuk mendukung jenis jaringan yang dipilih. Untuk menggunakan jenis jaringan koneksi IPv6 target, database Anda harus mendukung mode dual-stack.
**Tip**
Jika Anda belum mengetahui subnet yang akan digunakan IDs untuk `--vpc-subnet-ids` parameter, lihat [Menyiapkan prasyarat jaringan untuk RDS Proxy](rds-proxy-network-prereqs.md) contoh cara menemukannya.
**catatan**
Grup keamanan ini harus mengizinkan akses ke basis data yang terhubung ke proksi. Grup keamanan yang sama digunakan sebagai jalur masuk dari aplikasi ke proksi, dan jalur keluar dari proksi ke basis data. Misalnya, anggap saja Anda menggunakan grup keamanan yang sama untuk basis data dan proksi Anda. Dalam kasus ini, pastikan sumber daya dalam grup keamanan tersebut dapat berkomunikasi dengan sumber daya lain dalam grup keamanan yang sama.
Saat menggunakan VPC bersama, Anda tidak dapat menggunakan grup keamanan default untuk VPC, atau grup keamanan milik akun lain. Pilih grup keamanan milik akun Anda. Jika belum ada, buat. Untuk informasi selengkapnya tentang batasan ini, lihat [Bekerja dengan berbagi VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-sharing.html#vpc-share-limitations).
Untuk membuat asosiasi yang tepat untuk proxy, Anda juga menggunakan [register-db-proxy-targets](https://docs.aws.amazon.com/cli/latest/reference/rds/register-db-proxy-targets.html)perintah. Tentukan nama grup target `default`. Proksi RDS secara otomatis membuat grup target dengan nama ini saat Anda membuat setiap proksi.
```
aws rds register-db-proxy-targets
--db-proxy-name value
[--target-group-name target_group_name]
[--db-instance-identifiers space_separated_list] # rds db instances, or
[--db-cluster-identifiers cluster_id] # rds db cluster (all instances)
```
## API RDS
[Untuk membuat proxy RDS, panggil Create operasi Amazon RDS API. DBProxy](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBProxy.html) Anda melewati parameter dengan struktur [AuthConfig](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_AuthConfig.html)data.
Proksi RDS secara otomatis membuat grup target bernama `default` saat Anda membuat setiap proksi. Anda mengaitkan instance RDS DB cluster dengan grup target dengan memanggil [fungsi DBProxy](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RegisterDBProxyTargets.html) Register Targets.
**penting**
Bila Anda memilih **autentikasi IAM untuk skema otentikasi** default:
Anda harus mengaktifkan autentikasi database IAM pada instance atau cluster database target Anda sebelum proxy berhasil tersambung.
Jika Anda memilih **Buat peran IAM**, **akun Database untuk bidang autentikasi IAM** diperlukan.
Jika Anda memilih peran IAM yang ada, konsol tidak secara otomatis memperbarui peran dengan izin koneksi database. Periksa apakah peran tersebut memiliki `rds-db:connect` izin yang diperlukan.
# Melihat proxy
Setelah Anda membuat satu atau beberapa proxy RDS, Anda dapat melihat dan mengelolanya di Konsol Manajemen AWS, API AWS CLI, atau RDS. Anda dapat meninjau detail konfigurasi mereka, memantau kinerja, dan menentukan proxy mana yang akan dimodifikasi atau dihapus sesuai kebutuhan.
Untuk mengaktifkan aplikasi database untuk merutekan lalu lintas melalui proxy, Anda harus menentukan titik akhir proxy dalam string koneksi.
## Konsol
**Untuk melihat proxy di konsol**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih **Proksi**.
1. Pilih nama proxy untuk melihat detailnya.
1. Pada halaman detail, bagian **Grup target** menunjukkan bagaimana proxy ditautkan ke cluster DB instans RDS DB tertentu. Anda dapat menavigasi ke halaman grup target default untuk tampilan yang lebih dalam dari asosiasi ini, termasuk pengaturan konfigurasi yang ditentukan selama pembuatan proxy. Pengaturan ini mencakup persentase koneksi maksimum, batas waktu pinjam koneksi, keluarga mesin, dan filter penyematan sesi.
## CLI
Untuk melihat proxy Anda menggunakan CLI, gunakan perintah. [describe-db-proxies](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxies.html) Secara default, permintaan mengembalikan semua proxy yang dimiliki oleh akun Anda AWS . Untuk melihat detail dari satu proksi, masukkan namanya dengan parameter `--db-proxy-name`.
```
aws rds describe-db-proxies [--db-proxy-name proxy_name]
```
Untuk melihat informasi lain yang terkait dengan proxy, gunakan perintah berikut.
```
aws rds describe-db-proxy-target-groups --db-proxy-name proxy_name
aws rds describe-db-proxy-targets --db-proxy-name proxy_name
```
Gunakan urutan perintah berikut untuk melihat detail selengkapnya tentang hal-hal yang terkait dengan proksi:
1. Untuk mendapatkan daftar proxy, jalankan. [describe-db-proxies](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxies.html)
1. Untuk menampilkan parameter koneksi seperti persentase maksimum koneksi yang dapat digunakan proxy, jalankan [describe-db-proxy-target-groups](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxy-target-groups.html)`--db-proxy-name`. Gunakan nama proksi sebagai nilai parameter.
1. Untuk melihat detail cluster yang terkait dengan grup target yang dikembalikan, jalankan. [describe-db-proxy-targets](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxy-targets.html)
## API RDS
[Untuk melihat proxy Anda menggunakan RDS API, gunakan operasi Deskripsikan. DBProxies](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBProxies.html) Operasi ini akan menampilkan nilai dari jenis data [DBProxy](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DBProxy.html).
Untuk melihat detail pengaturan koneksi untuk proxy, gunakan pengidentifikasi proxy dari nilai pengembalian ini dengan DBProxy TargetGroups operasi [Deskripsikan](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBProxyTargetGroups.html). Operasi ini akan menampilkan nilai dari jenis data [DBProxyTargetGroup](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DBProxyTargetGroup.html).
Untuk melihat instans RDS atau cluster Aurora DB yang terkait dengan proxy, gunakan operasi [DBProxyDeskripsikan Target](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBProxyTargets.html). Ia mengembalikan nilai-nilai tipe data [DBProxyTarget](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DBProxyTarget.html).
# Terhubung ke basis data melalui Proksi RDS
Cara terhubung ke instans DB RDS melalui proksi atau dengan menghubungkan ke basis data umumnya sama. Untuk informasi selengkapnya, lihat [Ikhtisar titik akhir proksi](rds-proxy-endpoints.md#rds-proxy-endpoints-overview).
**Topics**
+ [Menghubungkan ke database menggunakan kredensi database](#rds-proxy-connecting-native)
+ [Menghubungkan ke database menggunakan otentikasi IAM](#rds-proxy-connecting-iam)
+ [Pertimbangan untuk menghubungkan ke Microsoft SQL Server](#rds-proxy-connecting-sqlserver)
+ [Pertimbangan untuk menghubungkan ke PostgreSQL](#rds-proxy-connecting-postgresql)
## Menghubungkan ke database menggunakan kredensi database
Gunakan langkah-langkah berikut untuk menyambung ke proxy menggunakan kredensil database:
1. Temukan titik akhir proksi. Di Konsol Manajemen AWS, Anda dapat menemukan titik akhir pada halaman detail untuk proxy yang sesuai. Dengan itu AWS CLI, Anda dapat menggunakan [describe-db-proxies](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxies.html)perintah. Contoh berikut menunjukkan caranya.
```
# Add --output text to get output as a simple tab-separated list.
$ aws rds describe-db-proxies --query '*[*].{DBProxyName:DBProxyName,Endpoint:Endpoint}'
[
[
{
"Endpoint": "the-proxy.proxy-demo.us-east-1.rds.amazonaws.com",
"DBProxyName": "the-proxy"
},
{
"Endpoint": "the-proxy-other-secret.proxy-demo.us-east-1.rds.amazonaws.com",
"DBProxyName": "the-proxy-other-secret"
},
{
"Endpoint": "the-proxy-rds-secret.proxy-demo.us-east-1.rds.amazonaws.com",
"DBProxyName": "the-proxy-rds-secret"
},
{
"Endpoint": "the-proxy-t3.proxy-demo.us-east-1.rds.amazonaws.com",
"DBProxyName": "the-proxy-t3"
}
]
]
```
1. Tentukan titik akhir sebagai parameter host dalam string koneksi untuk aplikasi klien Anda. Misalnya, tentukan titik akhir proksi sebagai nilai untuk opsi `mysql -h` atau opsi `psql -h`.
1. Masukkan nama dan kata sandi pengguna basis data yang sama seperti biasanya.
## Menghubungkan ke database menggunakan otentikasi IAM
Ketika Anda menggunakan otentikasi IAM dengan RDS Proxy, Anda memiliki dua opsi untuk otentikasi antara klien dan proxy Anda:
+ Siapkan pengguna database Anda untuk mengautentikasi dengan nama pengguna dan kata sandi biasa. RDS Proxy mengambil nama pengguna dan kredensi kata sandi dari Secrets Manager. Koneksi dari Proksi RDS ke basis data acuan tidak melewati IAM.
+ Anda juga dapat menggunakan autentikasi end-to-end IAM, yang menghubungkan ke database Anda melalui proxy menggunakan IAM tanpa memerlukan kredensi database.
Untuk terhubung ke Proksi RDS menggunakan autentikasi IAM, gunakan prosedur koneksi umum yang sama seperti autentikasi IAM dengan instans DB RDS. Untuk informasi umum tentang cara menggunakan IAM, lihat [Keamanan di Amazon RDS Aurora](UsingWithRDS.md). Jika Anda menggunakan otentikasi end-to-end IAM, berikan plugin otentikasi IAM kepada pengguna DB Anda. Lihat [Membuat akun basis data menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md).
Perbedaan utama dalam penggunaan IAM untuk Proksi RDS meliputi:
+ Dengan otentikasi IAM standar, pengguna database memiliki kredensi reguler dalam database. Anda dapat menyiapkan rahasia Secrets Manager yang berisi nama dan kata sandi pengguna ini, dan mengotorisasi Proksi RDS untuk mengambil kredensial dari Secrets Manager. Autentikasi IAM berlaku untuk koneksi antara program klien Anda dan proksi. Proksi kemudian melakukan autentikasi ke basis data menggunakan kredensial nama dan kata sandi pengguna yang diambil dari Secrets Manager.
+ Dengan autentikasi end-to-end IAM, Anda tidak perlu mengonfigurasi rahasia Secrets Manager untuk kredensi database. Autentikasi IAM berlaku untuk koneksi antara klien ke proxy dan proxy ke database.
+ Anda menentukan titik akhir proksi, bukan instans, klaster, atau titik akhir pembaca. Untuk detail tentang titik akhir proksi, lihat [Menghubungkan ke instans DB menggunakan autentikasi IAM](UsingWithRDS.IAMDBAuth.Connecting.md).
+ Pastikan Anda menggunakan Keamanan Lapisan Pengangkutan (TLS)/Lapisan Soket Aman (SSL) saat terhubung ke sebuah proksi menggunakan autentikasi IAM.
Anda dapat memberi pengguna tertentu akses ke proksi dengan mengubah kebijakan IAM. Berikut contohnya.
```
"Resource": "arn:aws:rds-db:us-east-2:1234567890:dbuser:prx-ABCDEFGHIJKL01234/db_user"
```
**Tip**
Saat mengonfigurasi autentikasi IAM untuk koneksi Proxy RDS, ikuti panduan penting ini untuk menghindari masalah koneksi:
Jangan berikan `rds_iam` peran sambil mempertahankan otentikasi kata sandi umum untuk pengguna atau peran database yang sama.
Ingat bahwa sementara klien terhubung ke RDS Proxy menggunakan autentikasi IAM, RDS Proxy selalu terhubung ke database menggunakan otentikasi kata sandi melalui Secrets Manager.
Jika Anda sering mengalami penghentian koneksi dan koneksi ulang, hapus semua `rds_iam` hibah yang ada dari pengguna atau peran dan gunakan hanya otentikasi kata sandi.
Pastikan kebijakan kata sandi Anda memenuhi persyaratan karakter aman SCRAM-SHA-256.
Mencampur IAM dan metode otentikasi kata sandi untuk pengguna database yang sama dapat menyebabkan ketidakstabilan koneksi.
## Pertimbangan untuk menghubungkan ke Microsoft SQL Server
Untuk terhubung ke proksi menggunakan autentikasi IAM, Anda tidak menggunakan kolom kata sandi. Sebagai gantinya, Anda memasukkan properti token yang sesuai untuk setiap jenis driver basis data di kolom token. Misalnya, gunakan properti `accessToken` untuk JDBC, atau properti `sql_copt_ss_access_token` untuk ODBC. Atau gunakan `AccessToken` properti untuk SqlClient driver.NET. Anda tidak dapat menggunakan autentikasi IAM dengan klien yang tidak mendukung properti token.
Dalam beberapa kondisi, proksi tidak dapat berbagi koneksi basis data dan sebagai gantinya menyematkan koneksi dari aplikasi klien Anda ke proksi ke koneksi basis data khusus. Untuk informasi selengkapnya tentang cara kondisi ini, lihat [Menghindari menyematkan Proxy RDS](rds-proxy-pinning.md).
## Pertimbangan untuk menghubungkan ke PostgreSQL
Jika Anda membuat pengguna database PostgreSQL baru untuk menghubungkan ke RDS Proxy, pastikan bahwa Anda memberikan hak istimewa pengguna pada database. `CONNECT` Tanpa ini, pengguna tidak dapat membuat koneksi. Untuk informasi selengkapnya, lihat [Menambahkan pengguna database baru ke database PostgreSQL saat menggunakan RDS Proxy](rds-proxy-new-db-user.md#rds-proxy-new-db-user-pg).
Ketika klien memulai koneksi ke database PostgreSQL, ia mengirimkan pesan startup. Pesan ini berisi pasangan nama parameter dan string nilai. Untuk detailnya, lihat `StartupMessage` dalam [PostgreSQL message formats](https://www.postgresql.org/docs/current/protocol-message-formats.html) dalam dokumentasi PostgreSQL.
Saat Anda terhubung melalui proxy RDS, pesan startup dapat menyertakan parameter berikut yang saat ini dikenali:
+ `user`
+ `database`
Pesan startup juga bisa menyertakan parameter runtime tambahan berikut:
+ `[application\$1name](https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-APPLICATION-NAME) `
+ `[client\$1encoding](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-CLIENT-ENCODING) `
+ `[DateStyle](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-DATESTYLE) `
+ `[TimeZone](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-TIMEZONE) `
+ `[extra\$1float\$1digits](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-EXTRA-FLOAT-DIGITS) `
+ `[ search\$1path ](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-SEARCH-PATH)`
Untuk informasi selengkapnya tentang pesan PostgreSQL, lihat [Frontend/Backend protocol](https://www.postgresql.org/docs/current/protocol.html) dalam dokumentasi PostgreSQL.
Untuk PostgreSQL, jika Anda menggunakan JDBC, sebaiknya lakukan tindakan berikut untuk menghindari penyematan:
+ Atur parameter koneksi JDBC `assumeMinServerVersion` ke setidaknya `9.0` untuk menghindari penyematan. Tindakan ini dapat mencegah driver JDBC melakukan perjalanan roundtrip ekstra selama startup koneksi saat menjalankan `SET extra_float_digits = 3`.
+ Atur parameter koneksi JDBC `ApplicationName` ke `any/your-application-name` untuk menghindari penyematan. Tindakan ini dapat mencegah driver JDBC melakukan roundtrip ekstra selama startup koneksi saat menjalankan `SET application_name = "PostgreSQL JDBC Driver"`. Perhatikan bahwa parameter JDBC adalah `ApplicationName`, tetapi parameter PostgreSQL `StartupMessage` adalah `application_name`.
Untuk informasi selengkapnya, lihat [Menghindari menyematkan Proxy RDS](rds-proxy-pinning.md). Untuk informasi selengkapnya tentang cara terhubung menggunakan JDBC, lihat [Connecting to the database](https://jdbc.postgresql.org/documentation/setup/) dalam dokumentasi PostgreSQL.