Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menghubungkan ke klaster DB menggunakan autentikasi IAM
Dengan autentikasi basis data IAM, Anda menggunakan token autentikasi ketika Anda terhubung ke klaster 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 Aurora 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 klaster DB Aurora. 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 klaster 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 cluster DB Anda menggunakan autentikasi IAM dengan driver AWS](IAMDBAuth.Connecting.Drivers.md)
+ [Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dari baris perintah: AWS CLI dan klien mysql](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dari baris perintah: AWS CLI dan klien psql](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dan AWS SDK untuk .NET](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Go](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Java](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Python (Boto3)](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# Menghubungkan ke cluster 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 dan menyadari topologi cluster 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 lebih lanjut tentang AWS driver, lihat driver bahasa yang sesuai untuk klaster Aurora [MySQL atau Aurora PostgreSQL DB](Aurora.Connecting.md#Aurora.Connecting.JDBCDriverMySQL) Anda.](Aurora.Connecting.md#Aurora.Connecting.AuroraPostgreSQL.Utilities)
# Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dari baris perintah: AWS CLI dan klien mysql
Anda dapat terhubung dari baris perintah ke cluster Aurora DB dengan AWS CLI alat baris perintah `mysql` dan seperti yang dijelaskan berikut.
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke klaster 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 klaster 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 klaster DB yang ingin Anda akses
+ `--port` – Nomor port yang digunakan untuk menghubungkan ke klaster DB Anda
+ `--region`— AWS Wilayah tempat cluster 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 klaster DB untuk menghasilkan token autentikasi.
## Menghubungkan ke klaster 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 klaster DB yang ingin Anda akses
+ `--port` – Nomor port yang digunakan untuk menghubungkan ke klaster DB Anda
+ `--ssl-ca` – Jalur lengkap ke file sertifikat SSL yang berisi kunci publik
Untuk informasi selengkapnya, lihat [Koneksi TLS ke cluster DB MySQL Aurora](AuroraMySQL.Security.md#AuroraMySQL.Security.SSL).
Untuk mengunduh sertifikat SSL, lihat [Menggunakan SSL/TLS untuk mengenkripsi koneksi ke ](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="mysqlcluster.cluster-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 klaster DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dari baris perintah: AWS CLI dan klien psql
Anda dapat terhubung dari baris perintah ke klaster DB Aurora PostgreSQL dengan AWS CLI dan alat baris perintah psql seperti yang dijelaskan berikut.
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke klaster 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 klaster Aurora 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="mypostgres-cluster.cluster-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 klaster (titik akhir klaster) DB yang ingin Anda akses
+ `--port` – Nomor port yang digunakan untuk menghubungkan ke klaster DB Anda
+ `--region`— AWS Wilayah tempat cluster DB berjalan
+ `--username` – Akun basis data yang ingin Anda akses
Beberapa karakter pertama dari token yang dihasilkan terlihat seperti berikut.
```
mypostgres-cluster.cluster-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 klaster DB untuk menghasilkan token autentikasi.
## Menghubungkan ke klaster Aurora 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 klaster (titik akhir klaster) DB yang ingin Anda akses
+ `port` – Nomor port yang digunakan untuk menghubungkan ke klaster DB Anda
+ `sslmode` – Mode SSL yang akan digunakan
Saat Anda menggunakan `sslmode=verify-full`, koneksi SSL memverifikasi titik akhir klaster DB di sertifikat SSL.
+ `sslrootcert` – Jalur lengkap ke file sertifikat SSL yang berisi kunci publik
Untuk informasi selengkapnya, lihat [Mengamankan data Aurora PostgreSQL dengan SSL/TLS](AuroraPostgreSQL.Security.md#AuroraPostgreSQL.Security.SSL).
Untuk mengunduh sertifikat SSL, lihat [Menggunakan SSL/TLS untuk mengenkripsi koneksi ke ](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 klaster 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="mypostgres-cluster.cluster-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 klaster DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dan AWS SDK untuk .NET
Anda dapat terhubung ke dengan seperti yang dijelaskan berikut. AWS SDK untuk .NET
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke klaster 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 klaster 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 cluster DB, gunakan konektor database.NET untuk mesin DB, seperti untuk MariaDB atau MySQL, atau Npgsql MySqlConnector untuk PostgreSQL.
Kode ini terhubung ke klaster DB Aurora MySQL. Ubah nilai variabel berikut sesuai kebutuhan:
+ `server` – Titik akhir klaster 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 klaster DB Anda
+ `SslMode` – Mode SSL yang akan digunakan
Saat Anda menggunakan `SslMode=Required`, koneksi SSL memverifikasi titik akhir klaster DB di sertifikat SSL.
+ `SslCa` – Jalur lengkap ke sertifikat SSL untuk Amazon Aurora
Untuk mengunduh sertifikat, lihat [Menggunakan SSL/TLS untuk mengenkripsi koneksi ke ](UsingWithRDS.SSL.md).
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir klaster 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, "mysqlcluster.cluster-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=mysqlcluster.cluster-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 klaster DB Aurora PostgreSQL.
Ubah nilai variabel berikut sesuai kebutuhan:
+ `Server` – Titik akhir klaster 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 klaster DB Anda
+ `SSL Mode` – Mode SSL yang akan digunakan
Saat Anda menggunakan `SSL Mode=Required`, koneksi SSL memverifikasi titik akhir klaster DB di sertifikat SSL.
+ `Root Certificate` – Jalur lengkap ke sertifikat SSL untuk Amazon Aurora
Untuk mengunduh sertifikat, lihat [Menggunakan SSL/TLS untuk mengenkripsi koneksi ke ](UsingWithRDS.SSL.md).
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir klaster 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("postgresmycluster.cluster-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=postgresmycluster.cluster-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 klaster DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Go
Anda dapat terhubung ke dengan seperti yang dijelaskan berikut. AWS SDK untuk Go
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke klaster 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 klaster DB yang ingin Anda akses
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir klaster DB untuk menghasilkan token autentikasi.
+ `dbPort` – Nomor port yang digunakan untuk menghubungkan ke klaster DB Anda
+ `region`— AWS Wilayah tempat cluster 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 cluster DB menggunakan autentikasi IAM dan V2. AWS SDK untuk Go
Contoh kode berikut ini menunjukkan cara membuat token autentikasi, lalu menggunakannya untuk menghubungkan ke klaster DB.
Kode ini terhubung ke klaster DB Aurora 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 = "mysqlcluster.cluster-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 klaster DB Aurora 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 = "postgresmycluster.cluster-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 klaster 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 cluster DB menggunakan otentikasi IAM dan V1 AWS SDK untuk Go
Contoh kode berikut ini menunjukkan cara membuat token autentikasi, lalu menggunakannya untuk menghubungkan ke klaster DB.
Kode ini terhubung ke klaster DB Aurora 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 := "mysqlcluster.cluster-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 klaster DB Aurora 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 := "postgresmycluster.cluster-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 klaster DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Java
Anda dapat terhubung ke dengan seperti yang dijelaskan berikut. AWS SDK untuk Java
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke klaster 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 klaster 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 klaster 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 klaster DB
Contoh kode berikut menunjukkan cara membuat token autentikasi, lalu menggunakannya untuk menghubungkan ke klaster yang menjalankan Aurora 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 Aurora yang khusus untuk AWS suatu Wilayah. (Untuk informasi selengkapnya, lihat [Menggunakan SSL/TLS untuk mengenkripsi koneksi ke ](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 klaster DB yang ingin Anda akses.
+ `RDS_INSTANCE_PORT` – Nomor port yang digunakan untuk menghubungkan ke klaster DB PostgreSQL Anda.
+ `REGION_NAME`— AWS Wilayah tempat cluster DB berjalan.
+ `DB_USER` – Akun basis data yang ingin Anda akses.
+ `SSL_CERTIFICATE`— Sertifikat SSL untuk Amazon Aurora yang khusus untuk suatu Wilayah. AWS
Untuk mengunduh sertifikat untuk Wilayah AWS Anda, lihat [Menggunakan SSL/TLS untuk mengenkripsi koneksi ke ](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 klaster DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Menghubungkan ke cluster DB Anda menggunakan otentikasi IAM dan AWS SDK untuk Python (Boto3)
Anda dapat terhubung ke dengan seperti yang dijelaskan berikut. AWS SDK untuk Python (Boto3)
**Prasyarat**
Berikut adalah prasyarat untuk menghubungkan ke klaster 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 klaster 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 klaster DB yang ingin Anda akses
+ `PORT` – Nomor port yang digunakan untuk menghubungkan ke klaster DB Anda
+ `USER` – Akun basis data yang ingin Anda akses
+ `REGION`— AWS Wilayah tempat cluster DB berjalan
+ `DBNAME` – Basis data yang ingin Anda akses
+ `SSLCERTIFICATE` – Jalur lengkap ke sertifikat SSL untuk Amazon Aurora
Untuk `ssl_ca`, tentukan sertifikat SSL. Untuk mengunduh sertifikat SSL, lihat [Menggunakan SSL/TLS untuk mengenkripsi koneksi ke ](UsingWithRDS.SSL.md).
**catatan**
Anda tidak dapat menggunakan data DNS Route 53 kustom sebagai pengganti titik akhir klaster DB untuk menghasilkan token autentikasi.
Kode ini terhubung ke klaster DB Aurora 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="mysqlcluster.cluster-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 klaster DB Aurora 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="postgresmycluster.cluster-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 klaster DB melalui proksi, lihat [Menghubungkan ke database menggunakan otentikasi IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).