# Conectar-se à instância de banco de dados usando a autenticação do IAM
Com a autenticação de banco de dados do IAM, você usa um token de autenticação ao se conectar à instância de banco de dados. Um *token de autenticação* é uma string de caracteres que você usa em vez de uma senha. Depois que você gerar um token de autenticação, ele será válido por 15 minutos antes de expirar. Se você tentar se conectar usando um token expirado, a solicitação de conexão será negada.
Todo token de autenticação deve ser acompanhado por uma assinatura válida, usando o Signature da AWS versão 4. (Para ter mais informações, consulte [Processo de assinatura do Signature versão 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) na * Referência geral da AWS.*) A AWS CLI e um SDK da AWS, como AWS SDK para Java ou AWS SDK para Python (Boto3), podem assinar automaticamente cada token que você criar.
Você pode usar um token de autenticação quando se conectar ao Amazon RDS de outro serviço da AWS, como o AWS Lambda. Ao usar um token, você não precisa inserir uma senha no seu código. Como alternativa, você pode usar o SDK da AWS para criar e assinar programaticamente um token de autenticação.
Depois que tiver um token de autenticação do IAM assinado, você poderá se conectar a uma instância de banco de dados do Amazon RDS. Veja a seguir como fazer isso usando uma ferramenta de linha de comando ou um SDK da AWS, como o AWS SDK para Java ou AWS SDK para Python (Boto3).
Para ter mais informações, consulte as seguintes postagens no blog:
+ [Use IAM authentication to connect with SQL Workbench/J to Aurora MySQL or Amazon RDS para MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/)
+ [Using IAM authentication to connect with pgAdmin Amazon Aurora PostgreSQL or Amazon RDS para PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)
**Pré-requisitos**
Veja a seguir os pré-requisitos para se conectar à instância de banco de dados usando a autenticação do IAM:
+ [Habilitar e desabilitar a autenticação de banco de dados do IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Criar uma conta de banco de dados usando autenticação do IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [Conectar-se à instância de banco de dados usando a autenticação do IAM com os drivers da AWS.](IAMDBAuth.Connecting.Drivers.md)
+ [Conectando-se à sua instância de banco de dados usando a autenticação do IAM na linha de comando: AWS CLI e cliente mysql](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [Conectar a instância de banco de dados usando a autenticação do IAM na linha de comando: AWS CLI e cliente psql](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [Conectar-se à instância de banco de dados usando a autenticação do IAM e o AWS SDK para .NET](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [Conectar-se à instância de banco de dados usando a autenticação do IAM e o AWS SDK para Go](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [Conectar-se à instância de banco de dados usando a autenticação do IAM e o AWS SDK para Java](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [Conectar-se à instância de banco de dados usando a autenticação do IAM e o AWS SDK para Python (Boto3)](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# Conectar-se à instância de banco de dados usando a autenticação do IAM com os drivers da AWS.
O pacote de drivers da AWS foram projetados para comportar tempos mais rápidos de transição e de failover, além de autenticação com o AWS Secrets Manager, o AWS Identity and Access Management (IAM) e identidades federadas. Os drivers da AWS dependem do monitoramento do status da instância de banco de dados e do conhecimento da topologia da instância para determinar o novo gravador. Essa abordagem reduz os tempos de transição e de failover para segundos de um dígito, em comparação com dezenas de segundos para drivers de código aberto.
Para ter mais informações sobre os drivers da AWS, consulte o driver de linguagem correspondente para a instância de banco de dados do [RDS para MariaDB](MariaDB.Connecting.Drivers.md#MariaDB.Connecting.JDBCDriver), [RDS para MySQL](MySQL.Connecting.Drivers.md#MySQL.Connecting.JDBCDriver) ou [RDS para PostgreSQL](PostgreSQL.Connecting.JDBCDriver.md).
**nota**
Os únicos recursos compatíveis com o RDS para MariaDB são a autenticação com o AWS Secrets Manager, o AWS Identity and Access Management (IAM) e a identidade federada.
# Conectando-se à sua instância de banco de dados usando a autenticação do IAM na linha de comando: AWS CLI e cliente mysql
Você pode se conectar de uma linha de comando a uma instância de banco de dados do Amazon RDS com a AWS CLI e a ferramenta da linha de comando `mysql`, conforme descrito a seguir.
**Pré-requisitos**
Veja a seguir os pré-requisitos para se conectar à instância de banco de dados usando a autenticação do IAM:
+ [Habilitar e desabilitar a autenticação de banco de dados do IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Criar uma conta de banco de dados usando autenticação do IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**nota**
Para obter informações sobre como se conectar ao banco de dados usando o SQL Workbench/J com autenticação do IAM, consulte a publicação do blog [Use IAM authentication to connect with SQL Workbench/J to Aurora MySQL or Amazon RDS para 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**
+ [Gerar um token de autenticação do IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [Conexão à instância de banco de dados](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)
## Gerar um token de autenticação do IAM
O exemplo a seguir mostra como obter um token de autenticação assinado usando a 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
```
No exemplo, os parâmetros são os seguintes:
+ `--hostname`: o nome do host da instância de banco de dados que você deseja acessar
+ `--port`: o número da porta usada para se conectar à instância de banco de dados
+ `--region`: a região da AWS na qual a instância do banco de dados está em execução.
+ `--username`: a conta de banco de dados que você deseja acessar
Os primeiros caracteres do token são parecidos com os seguintes.
```
rdsmysql.123456789012.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**nota**
Não é possível usar um registro DNS personalizado do Route 53 em vez do endpoint da instância de banco de dados para gerar o token de autenticação.
## Conexão à instância de banco de dados
O formato geral para se conectar é mostrado a seguir.
```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```
Os parâmetros são os seguintes:
+ `--host`: o nome do host da instância de banco de dados que você deseja acessar
+ `--port`: o número da porta usada para se conectar à instância de banco de dados
+ `--ssl-ca`: o caminho completo para o arquivo de certificado SSL que contém a chave pública
Para ter mais informações sobre o suporte SSL/TLS para o MariaDB, consulte [Suporte de SSL/TLS para instâncias de banco de dados do MariaDB no Amazon RDS](MariaDB.Concepts.SSLSupport.md).
Para ter mais informações sobre o suporte SSL/TLS para o MySQL, consulte [Suporte do SSL/TLS para instâncias de banco de dados do MySQL no Amazon RDS](MySQL.Concepts.SSLSupport.md).
Para baixar um certificado SSL, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).
+ `--enable-cleartext-plugin`: um valor que especifica que o `AWSAuthenticationPlugin` deve ser usado para essa conexão
Se você estiver usando um cliente MariaDB, a opção`--enable-cleartext-plugin` não será necessária.
+ `--user`: a conta de banco de dados que você deseja acessar
+ `--password`: um token de autenticação do IAM assinado
Um token de autenticação é composto de várias centenas de caracteres. Ele pode ser incômodo para a linha de comando. Um modo de contornar isso é salvar o token em uma variável de ambiente, e usar essa variável quando você se conectar. O exemplo a seguir mostra um modo de executar essa solução alternativa. No exemplo, */sample\$1dir/* corresponde ao caminho completo do arquivo de certificado SSL contendo a chave pública.
```
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
```
Quando você se conecta usando o `AWSAuthenticationPlugin`, a conexão é protegida usando SSL. Para verificar isso, digite o seguinte no prompt de comando `mysql>`.
```
show status like 'Ssl%';
```
As seguintes linhas na saída mostram mais detalhes.
```
+---------------+-------------+
| Variable_name | Value |
+---------------+-------------+
| ... | ...
| Ssl_cipher | AES256-SHA |
| ... | ...
| Ssl_version | TLSv1.1 |
| ... | ...
+-----------------------------+
```
Se você quiser se conectar a uma instância de banco de dados por meio de um proxy, consulte [Conectar-se a um banco de dados usando autenticação do IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conectar a instância de banco de dados usando a autenticação do IAM na linha de comando: AWS CLI e cliente psql
Conecte-se pela linha de comando a uma instância de banco de dados do Amazon RDS para PostgreSQL com a AWS CLI e a ferramenta da linha de comando psql conforme descrito a seguir.
**Pré-requisitos**
Veja a seguir os pré-requisitos para se conectar à instância de banco de dados usando a autenticação do IAM:
+ [Habilitar e desabilitar a autenticação de banco de dados do IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Criar uma conta de banco de dados usando autenticação do IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**nota**
Para obter informações sobre como se conectar ao seu banco de dados usando pgAdmin com autenticação do IAM, consulte a publicação do blog [Using IAM authentication to connect with pgAdmin Amazon Aurora PostgreSQL or Amazon RDS para PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/).
**Topics**
+ [Gerar um token de autenticação do IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [Conectar-se a uma instância PostgreSQL do Amazon RDS](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)
## Gerar um token de autenticação do IAM
Um token de autenticação é composto de várias centenas de caracteres. Dessa maneira, ele pode ficar estranho na linha de comando. Um modo de contornar isso é salvar o token em uma variável de ambiente, e usar essa variável quando você se conectar. O exemplo a seguir mostra como usar a AWS CLI para obter um token de autenticação assinado usando o comando `generate-db-auth-token` e armazená-lo em uma variável de ambiente `PGPASSWORD`.
```
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 )"
```
No exemplo, os parâmetros para o comando `generate-db-auth-token` são os seguintes:
+ `--hostname`: o nome do host da instância de banco de dados que você deseja acessar
+ `--port`: o número da porta usada para se conectar à instância de banco de dados
+ `--region`: a região da AWS na qual a instância do banco de dados está em execução.
+ `--username`: a conta de banco de dados que você deseja acessar
Os primeiros caracteres do token gerado são parecidos com os seguintes.
```
rdspostgres.123456789012.us-west-2.rds.amazonaws.com:5432/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**nota**
Não é possível usar um registro DNS personalizado do Route 53 em vez do endpoint da instância de banco de dados para gerar o token de autenticação.
## Conectar-se a uma instância PostgreSQL do Amazon RDS
O formato geral para usar psql na conexão é mostrado a seguir.
```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```
Os parâmetros são os seguintes:
+ `host`: o nome do host da instância de banco de dados que você deseja acessar
+ `port`: o número da porta usada para se conectar à instância de banco de dados
+ `sslmode`: o modo SSL a ser usado
Quando você usa `sslmode=verify-full`, a conexão SSL verifica o endpoint da instância de banco de dados em relação ao endpoint no certificado SSL.
+ `sslrootcert`: o caminho completo para o arquivo de certificado SSL que contém a chave pública
Para ter mais informações, consulte [Usar o SSL com uma instância de banco de dados PostgreSQL](PostgreSQL.Concepts.General.SSL.md).
Para baixar um certificado SSL, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).
+ `dbname`: o banco de dados que você deseja acessar
+ `user`: a conta de banco de dados que você deseja acessar
+ `password`: um token de autenticação do IAM assinado
**nota**
Não é possível usar um registro DNS personalizado do Route 53 em vez do endpoint da instância de banco de dados para gerar o token de autenticação.
O exemplo a seguir mostra o uso do psql para conexão. No exemplo, psql usa a variável de ambiente `RDSHOST` para o host e a variável de ambiente `PGPASSWORD` para o token gerado. Além disso, */sample\$1dir/* corresponde ao caminho completo do arquivo de certificado SSL contendo a chave pública.
```
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"
```
Se você quiser se conectar a uma instância de banco de dados por meio de um proxy, consulte [Conectar-se a um banco de dados usando autenticação do IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conectar-se à instância de banco de dados usando a autenticação do IAM e o AWS SDK para .NET
Você pode se conectar a uma instância de banco de dados do RDS para MariaDB, RDS para MySQL ou RDS para PostgreSQL com a AWS SDK para .NET, conforme descrito a seguir.
**Pré-requisitos**
Veja a seguir os pré-requisitos para se conectar à instância de banco de dados usando a autenticação do IAM:
+ [Habilitar e desabilitar a autenticação de banco de dados do IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Criar uma conta de banco de dados usando autenticação do IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Exemplos**
O exemplo de código a seguir mostra como gerar um token de autenticação e usá-lo para se conectar a uma instância de banco de dados.
Para executar esse exemplo de código, você precisa do [AWS SDK para .NET](https://aws.amazon.com/sdk-for-net/), encontrado no site AWS. Os pacotes `AWSSDK.CORE` e `AWSSDK.RDS` são necessários. Para se conectar a uma instância de banco de dados, use o conector de banco de dados .NET para o mecanismo de banco de dados, como MySqlConnector para MariaDB ou MySQL ou Npgsql para PostgreSQL.
Esse código se conecta a uma instância de banco de dados MariaDB ou MySQL. Modifique os valores das seguintes variáveis, conforme necessário:
+ `server`: o endpoint da instância de banco de dados que você deseja acessar
+ `user`: a conta de banco de dados que você deseja acessar
+ `database`: o banco de dados que você deseja acessar
+ `port`: o número da porta usada para se conectar à instância de banco de dados
+ `SslMode`: o modo SSL a ser usado
Quando você usa `SslMode=Required`, a conexão SSL verifica o endpoint da instância de banco de dados em relação ao endpoint no certificado SSL.
+ `SslCa`: o caminho completo para o certificado SSL do Amazon RDS
Para baixar um certificado, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).
**nota**
Não é possível usar um registro DNS personalizado do Route 53 em vez do endpoint da instância de banco de dados para gerar o token de autenticação.
```
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();
}
}
}
```
Esse código se conecta a uma instância de banco de dados PostgreSQL.
Modifique os valores das seguintes variáveis, conforme necessário:
+ `Server`: o endpoint da instância de banco de dados que você deseja acessar
+ `User ID`: a conta de banco de dados que você deseja acessar
+ `Database`: o banco de dados que você deseja acessar
+ `Port`: o número da porta usada para se conectar à instância de banco de dados
+ `SSL Mode`: o modo SSL a ser usado
Quando você usa `SSL Mode=Required`, a conexão SSL verifica o endpoint da instância de banco de dados em relação ao endpoint no certificado SSL.
+ `Root Certificate`: o caminho completo para o certificado SSL do Amazon RDS
Para baixar um certificado, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).
**nota**
Não é possível usar um registro DNS personalizado do Route 53 em vez do endpoint da instância de banco de dados para gerar o token de autenticação.
```
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();
}
}
}
```
Se você quiser se conectar a uma instância de banco de dados por meio de um proxy, consulte [Conectar-se a um banco de dados usando autenticação do IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conectar-se à instância de banco de dados usando a autenticação do IAM e o AWS SDK para Go
Você pode se conectar a uma instância de banco de dados do RDS para MariaDB, RDS para MySQL ou RDS para PostgreSQL com a AWS SDK para Go, conforme descrito a seguir.
**Pré-requisitos**
Veja a seguir os pré-requisitos para se conectar à instância de banco de dados usando a autenticação do IAM:
+ [Habilitar e desabilitar a autenticação de banco de dados do IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Criar uma conta de banco de dados usando autenticação do IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Exemplos**
Para executar esses exemplos de código, você precisa do [AWS SDK para Go](https://aws.amazon.com/sdk-for-go/), encontrado no site AWS.
Modifique os valores das seguintes variáveis, conforme necessário:
+ `dbName`: o banco de dados que você deseja acessar
+ `dbUser`: a conta de banco de dados que você deseja acessar
+ `dbHost`: o endpoint da instância de banco de dados que você deseja acessar
**nota**
Não é possível usar um registro DNS personalizado do Route 53 em vez do endpoint da instância de banco de dados para gerar o token de autenticação.
+ `dbPort`: o número da porta usada para se conectar à instância de banco de dados
+ `region`: a região da AWS na qual a instância do banco de dados está em execução.
Além disso, verifique se as bibliotecas importadas no código de exemplo existem no sistema.
**Importante**
Os exemplos nesta seção usam o seguinte código para fornecer credenciais que acessam um banco de dados a partir de um ambiente local:
`creds := credentials.NewEnvCredentials()`
Se estiver acessando um banco de dados de um serviço da AWS, como o Amazon EC2 ou Amazon ECS, você poderá substituir o código pelo seguinte código:
`sess := session.Must(session.NewSession())`
`creds := sess.Config.Credentials`
Se você fizer essa alteração, certifique-se de adicionar a seguinte importação:
`"github.com/aws/aws-sdk-go/aws/session"`
**Topics**
+ [Conectar-se usando a autenticação do IAM e o AWS SDK para Go V2](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [Conectar-se usando a autenticação do IAM e o AWS SDK para Go V1.](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)
## Conectar-se usando a autenticação do IAM e o AWS SDK para Go V2
Conecte-se a uma instância de banco de dados usando a autenticação do IAM e o AWS SDK para Go V2.
O exemplo de código a seguir mostra como gerar um token de autenticação e usá-lo para se conectar a uma instância de banco de dados.
Esse código se conecta a uma instância de banco de dados MariaDB ou 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)
}
}
```
Esse código se conecta a uma instância de banco de dados 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)
}
}
```
Se você quiser se conectar a uma instância de banco de dados por meio de um proxy, consulte [Conectar-se a um banco de dados usando autenticação do IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
## Conectar-se usando a autenticação do IAM e o AWS SDK para Go V1.
Conecte-se a um cluster de banco de dados usando a autenticação do IAM e o AWS SDK para Go V1
O exemplo de código a seguir mostra como gerar um token de autenticação e usá-lo para se conectar a uma instância de banco de dados.
Esse código se conecta a uma instância de banco de dados MariaDB ou 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)
}
}
```
Esse código se conecta a uma instância de banco de dados 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)
}
}
```
Se você quiser se conectar a uma instância de banco de dados por meio de um proxy, consulte [Conectar-se a um banco de dados usando autenticação do IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conectar-se à instância de banco de dados usando a autenticação do IAM e o AWS SDK para Java
Você pode se conectar a uma instância de banco de dados do RDS para MariaDB, RDS para MySQL ou RDS para PostgreSQL com a AWS SDK para Java, conforme descrito a seguir.
**Pré-requisitos**
Veja a seguir os pré-requisitos para se conectar à instância de banco de dados usando a autenticação do IAM:
+ [Habilitar e desabilitar a autenticação de banco de dados do IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Criar uma conta de banco de dados usando autenticação do IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Configurar o AWS SDK for Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
Consulte exemplos de como usar o SDK para Java 2.x em [Amazon RDS examples using SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html). Você também pode usar o AWS Advanced JDBC Wrapper. Para isso, consulte a documentação do [AWS Advanced JDBC Wrapper](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md).
**Topics**
+ [Gerar um token de autenticação do IAM](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [Criar manualmente um token de autenticação do IAM](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [Conexão à instância de banco de dados](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)
## Gerar um token de autenticação do IAM
Se estiver escrevendo programas usando o AWS SDK para Java, você pode obter um token de autenticação assinado usando a classe `RdsIamAuthTokenGenerator`. O uso dessa classe exige que você forneça as credenciais da AWS. Para fazer isso, crie uma instância da classe `DefaultAWSCredentialsProviderChain`. `DefaultAWSCredentialsProviderChain` usa a primeira chave de acesso da AWS e a chave secreta encontradas na [cadeia de fornecedores de credencial padrão](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default). Para ter mais informações sobre chaves de acesso da AWS, consulte [Gerenciar chaves de acesso para usuários](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**nota**
Não é possível usar um registro DNS personalizado do Route 53 em vez do endpoint da instância de banco de dados para gerar o token de autenticação.
Após criar uma instância de `RdsIamAuthTokenGenerator`, você pode chamar o método `getAuthToken` para obter um token assinado. Forneça a região da AWS, o nome do host, o número da porta e o nome do usuário. O exemplo de código a seguir ilustra como fazer isso.
```
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;
}
}
```
## Criar manualmente um token de autenticação do IAM
No Java, o modo mais fácil de gerar um token de autenticação é usar o `RdsIamAuthTokenGenerator`. Essa classe cria um token de autenticação para você e assina-o usando o Signature da AWS versão 4. Para ter mais informações, consulte [Processo de assinatura do Signature versão 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) na *Referência geral da AWS*.
No entanto, você também pode construir e assinar um token de autenticação manualmente, conforme mostrado no exemplo de código a seguir.
```
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);
}
}
}
```
## Conexão à instância de banco de dados
O exemplo de código a seguir mostra como gerar um token de autenticação e usá-lo para se conectar a uma instância que esteja executando o MariaDB ou MySQL.
Para executar esse exemplo de código, você precisa do [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/), encontrado no site AWS. Além disso, você precisa do seguinte:
+ MySQL Connector/J. Este exemplo de código foi testado com `mysql-connector-java-5.1.33-bin.jar`.
+ Um certificado intermediário do Amazon RDS específico de uma região da AWS. (Para ter mais informações, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).) No tempo de execução, o carregador de classe procura o certificado no mesmo diretório do exemplo de código Java para que possa encontrá-lo.
+ Modifique os valores das seguintes variáveis, conforme necessário:
+ `RDS_INSTANCE_HOSTNAME`: o nome do host da instância de banco de dados que você deseja acessar.
+ `RDS_INSTANCE_PORT`: o número da porta usado na conexão com a instância de banco de dados PostgreSQL.
+ `REGION_NAME`: a região da AWS na qual a instância do banco de dados está em execução.
+ `DB_USER`: a conta de banco de dados que você deseja acessar.
+ `SSL_CERTIFICATE`: um certificado SSL para o Amazon RDS que é específico de uma região da AWS.
Para baixar o certificado para a sua região da AWS, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md). Coloque o certificado do SSL no mesmo diretório que esse arquivo do programa Java para que o carregador de classe possa encontrar o certificado no tempo de execução.
Esse exemplo de código obtém as credenciais da AWS a partir da[cadeia de fornecedores de credencial padrão](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default).
**nota**
Especifique uma senha para `DEFAULT_KEY_STORE_PASSWORD` diferente do prompt mostrado aqui como prática recomendada de segurança.
```
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");
}
}
```
Se você quiser se conectar a uma instância de banco de dados por meio de um proxy, consulte [Conectar-se a um banco de dados usando autenticação do IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conectar-se à instância de banco de dados usando a autenticação do IAM e o AWS SDK para Python (Boto3)
Você pode se conectar a uma instância de banco de dados do RDS para MariaDB, RDS para MySQL ou RDS para PostgreSQL com a AWS SDK para Python (Boto3), conforme descrito a seguir.
**Pré-requisitos**
Veja a seguir os pré-requisitos para se conectar à instância de banco de dados usando a autenticação do IAM:
+ [Habilitar e desabilitar a autenticação de banco de dados do IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Criar uma conta de banco de dados usando autenticação do IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
Além disso, verifique se as bibliotecas importadas no código de exemplo existem no sistema.
**Exemplos**
Os exemplos de código usam perfis para credenciais compartilhadas. Para obter informações sobre a especificação de credenciais, consulte [Credenciais](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) na documentação AWS SDK para Python (Boto3).
O exemplo de código a seguir mostra como gerar um token de autenticação e usá-lo para se conectar a uma instância de banco de dados.
Para executar esse exemplo de código, você precisa do [AWS SDK para Python (Boto3)](https://aws.amazon.com/sdk-for-python/), encontrado no site AWS.
Modifique os valores das seguintes variáveis, conforme necessário:
+ `ENDPOINT`: o endpoint da instância de banco de dados que você deseja acessar
+ `PORT`: o número da porta usada para se conectar à instância de banco de dados
+ `USER`: a conta de banco de dados que você deseja acessar
+ `REGION`: a região da AWS na qual a instância do banco de dados está em execução.
+ `DBNAME`: o banco de dados que você deseja acessar
+ `SSLCERTIFICATE`: o caminho completo para o certificado SSL do Amazon RDS
Para `ssl_ca`, defina um certificado SSL. Para baixar um certificado SSL, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).
**nota**
Não é possível usar um registro DNS personalizado do Route 53 em vez do endpoint da instância de banco de dados para gerar o token de autenticação.
Esse código se conecta a uma instância de banco de dados MariaDB ou MySQL.
Antes de executar esse código, instale o driver PyMySQL seguindo as instruções no [Python Package Index](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))
```
Esse código se conecta a uma instância de banco de dados PostgreSQL.
Antes de executar esse código, instale `psycopg2`, seguindo as instruções na [documentação de 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))
```
Se você quiser se conectar a uma instância de banco de dados por meio de um proxy, consulte [Conectar-se a um banco de dados usando autenticação do IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).