Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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).