# Autenticação do banco de dados do IAMpara MariaDB, MySQL e PostgreSQL
Você pode se autenticar a instância de banco de dados usando a autenticação de banco de dados do AWS Identity and Access Management (IAM). A autenticação do banco de dados do IAM funciona com o MariaDB, MySQL e o PostgreSQL. Com esse método de autenticação, você não precisa usar uma senha ao conectar-se a um cluster de de banco de dados. Em vez disso, você usa um token de autenticação.
Um *token de autenticação* é uma string exclusiva de caracteres que o Amazon RDS gera mediante solicitação. Os tokens de autenticação são gerados usando o Signature da AWS versão 4. Cada token tem uma vida útil de 15 minutos. Você não precisa armazenar as credenciais de usuário no banco de dados, porque a autenticação é gerenciada externamente usando o IAM. Você também pode usar a autenticação de banco de dados padrão. O token é usado apenas para autenticação e não afetará a sessão depois que ela for estabelecida.
A autenticação do banco de dados do IAM oferece os seguintes benefícios:
+ O tráfego de rede de e para o banco de dados é criptografado usando Secure Socket Layer (SSL) ou Transport Layer Security (TLS). Para obter mais informações sobre como usar SSL/TLS com o Amazon RDS, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).
+ Você pode usar o IAM para gerenciar centralmente o acesso aos recursos de banco de dados, em vez de gerenciar o acesso individualmente em cada instância de banco de dados.
+ Para aplicações em execução no Amazon EC2, você pode usar as credenciais específicas da instância do EC2 para acessar o banco de dados em vez de uma senha para maior segurança.
Em geral, considere usar a autenticação de banco de dados do IAM quando suas aplicações criam menos de 200 conexões por segundo e você não deseja gerenciar nomes de usuário e senhas diretamente no código da aplicação.
O driver JDBC da Amazon Web Services (AWS) comporta a autenticação do banco de dados do IAM. Para ter mais informações, consulte [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) no [Amazon Web Services (AWS) JDBC Driver GitHub repository](https://github.com/aws/aws-advanced-jdbc-wrapper).
O driver Python da Amazon Web Services (AWS) comporta a autenticação do banco de dados do IAM. Para ter mais informações, consulte [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) no [Amazon Web Services (AWS) Python Driver GitHub repository](https://github.com/aws/aws-advanced-python-wrapper).
Navegue pelos tópicos a seguir para aprender o processo de configuração do IAM para autenticação de banco de dados:
+ [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)
+ [Conectar-se à instância de banco de dados usando a autenticação do IAM](UsingWithRDS.IAMDBAuth.Connecting.md)
## Disponibilidade de regiões e versões
A disponibilidade e a compatibilidade de recursos variam entre versões específicas de cada mecanismo de banco de dados. Para ter mais informações sobre a disponibilidade de versões e regiões com o Amazon RDS e a autenticação de banco de dados do IAM, consulte [Regiões e mecanismos de banco de dados compatíveis com a autenticação de banco de dados do IAM no Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.IamDatabaseAuthentication.md).
## Suporte para CLI e SDK
A autenticação de banco de dados do IAM está disponível para a [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html) e para os seguintes AWS SDKs específicos à linguagem:
+ [AWS SDK para .NET](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/RDS/TRDSAuthTokenGenerator.html)
+ [AWS SDK para C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/class_aws_1_1_r_d_s_1_1_r_d_s_client.html#ae134ffffed5d7672f6156d324e7bd392)
+ [AWS SDK para Go](https://docs.aws.amazon.com/sdk-for-go/api/service/rds/#pkg-overview)
+ [AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/rds/RdsUtilities.html)
+ [AWS SDK para JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_rds_signer.html)
+ [AWS SDK para PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.Rds.AuthTokenGenerator.html)
+ [AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.generate_db_auth_token)
+ [AWS SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/RDS/AuthTokenGenerator.html)
## Limitações para a autenticação de banco de dados do IAM
Ao usar a autenticação do banco de dados do IAM, as seguintes limitações se aplicam:
+ Atualmente, a autenticação do banco de dados do IAM não oferece suporte a todas as chaves de contexto de condição global.
Para obter mais informações sobre chaves de contexto de condição global, consulte [Chaves de contexto de condição global AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
+ No PostgreSQL, se o perfil do IAM (`rds_iam`) for adicionado a um usuário (por exemplo, o usuário principal do RDS), a autenticação do IAM terá precedência sobre a autenticação por senha, então o usuário precisará fazer login como um usuário do IAM.
+ Para o PostgreSQL, o Amazon RDS não permite a habilitação dos métodos de autenticação do IAM e do Kerberos ao mesmo tempo.
+ Em relação ao PostgreSQL, não é possível usar a autenticação do IAM para estabelecer uma conexão de replicação.
+ 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 CloudWatch e o CloudTrail não registram em log a autenticação do IAM. Esses serviços não rastreiam chamadas de API `generate-db-auth-token` que autorizam o perfil do IAM a habilitar a conexão com o banco de dados.
+ A autenticação de banco de dados do IAM requer recursos de computação na instância de banco de dados. É necessário ter entre 300 MiB e 1.000 MiB extras de memória no banco de dados para ter uma conectividade confiável. Para ver a memória necessária para a workload, compare a coluna RES para processos do RDS na lista de processos do monitoramento avançado antes e depois de habilitar a autenticação de banco de dados do IAM. Consulte [Como visualizar métricas do SO no console do RDS](USER_Monitoring.OS.Viewing.md).
Se você estiver usando uma instância de classe com capacidade de expansão, evite ficar sem memória reduzindo a memória usada por outros parâmetros, como buffers e cache, na mesma quantidade.
+ Não é possível usar a autenticação de banco de dados do IAM com o RDS no Outposts em nenhum mecanismo.
## Recomendações para autenticação de banco de dados do IAM
Recomendamos o seguinte durante o uso da autenticação do banco de dados do IAM:
+ Use a autenticação de banco de dados do IAM quando sua aplicação exigir menos de 200 novas conexões de autenticação de banco de dados do IAM por segundo.
Os mecanismos de banco de dados que funcionam com o Amazon RDS não impõem quaisquer limites para as tentativas de autenticação por segundo. No entanto, quando você usa a autenticação de banco de dados do IAM, sua aplicação deve gerar um token de autenticação. Sua aplicação então usa esse token para se conectar à instância de banco de dados. Se você exceder o limite de novas conexões máximas por segundo, a sobrecarga extra da autenticação de banco de dados IAM poderá causar a limitação da conexão.
Considere usar o agrupamento de conexões em suas aplicações para mitigar a criação constante de conexões. Isso pode reduzir a sobrecarga da autenticação de banco de dados do IAM e permitir que as aplicações reutilizem as conexões existentes. Como alternativa, considere usar o RDS Proxy para esses casos. O RDS Proxy tem custos adicionais. Consulte [Preços do RDS Proxy](https://aws.amazon.com/rds/proxy/pricing/).
+ O tamanho de um token de autenticação de banco de dados do IAM depende de muitas coisas, incluindo o número de etiquetas do IAM, políticas de serviço do IAM, comprimentos de ARN, bem como outras propriedades do IAM e do banco de dados. O tamanho mínimo desse token geralmente é de cerca de 1 KB, mas pode ser maior. Como esse token é usado como senha na string de conexão com o banco de dados por meio da autenticação do IAM, você deve garantir que o driver de banco de dados (por exemplo, ODBC) e/ou quaisquer ferramentas não limitem nem trunquem esse token devido ao respectivo tamanho. Um token truncado fará com que a validação da autenticação feita pelo banco de dados e pelo IAM falhe.
+ Se você estiver usando credenciais temporárias ao criar um token de autenticação do banco de dados do IAM, as credenciais temporárias ainda deverão ser válidas ao usar o token de autenticação do banco de dados do IAM para fazer uma solicitação de conexão.
## Chaves de contexto de condição globais da AWS incompatíveis
A autenticação do banco de dados do IAM não é compatível com o seguinte subconjunto de chaves de contexto de condição global da AWS.
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`
Para obter mais informações, consulte [Chaves de contexto de condição global da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
# Habilitar e desabilitar a autenticação de banco de dados do IAM
Por padrão, a autenticação de banco de dados do IAM está desabilitada nas instâncias de banco de dados. É possível habilitar ou desabilitar a autenticação de banco de dados do IAM usando o Console de gerenciamento da AWS, a AWS CLI ou a API.
É possível habilitar a autenticação de banco de dados do IAM ao executar uma das seguintes ações:
+ Para criar uma nova instância de banco de dados com autenticação de banco de dados do IAM habilitada, consulte [Criar uma instância de banco de dados do Amazon RDS](USER_CreateDBInstance.md).
+ Para modificar uma instância de banco de dados para habilitar a autenticação de banco de dados do IAM, consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md).
+ Para restaurar uma instância de banco de dados de um snapshot com a autenticação de banco de dados do IAM habilitada, consulte [Restaurar uma instância de banco de dados](USER_RestoreFromSnapshot.md).
+ Para restaurar uma instância de banco de dados em um momento específico com a autenticação de banco de dados do IAM habilitada, consulte [Restaurar uma instância de banco de dados para um momento especificado no Amazon RDS](USER_PIT.md).
## Console
Cada fluxo de trabalho de criação ou modificação tem uma seção **Database authentication (Autenticação de banco de dados)**, onde é possível habilitar ou desabilitar a autenticação de banco de dados do IAM. Nessa seção, escolha **Password and IAM database authentication (Senha e autenticação do banco de dados do IAM)** para habilitar a autenticação do banco de dados do IAM.
**Para habilitar ou desabilitar a autenticação do banco de dados do IAM para uma instância de banco de dados existente**
1. Abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação, escolha **Databases (Bancos de dados)**.
1. Escolha a instância de banco de dados que você deseja modificar.
**nota**
Certifique-se de que a instância de banco de dados seja compatível com a autenticação do IAM. Verifique os requisitos de compatibilidade em [Disponibilidade de regiões e versões](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
1. Selecione **Modify**.
1. Na seção **Autenticação do banco de dados**, escolha **Senha e autenticação do banco de dados do IAM** para habilitar a autenticação do banco de dados do IAM. Escolha **Autenticação de senha** ou **Senha e autenticação Kerberos** para desabilitar a autenticação do IAM.
1. Você também pode optar por habilitar a publicação de logs de autenticação de banco de dados do IAM no CloudWatch Logs. Em **Exportações de log**, escolha a opção **Log iam-db-auth-error**. A publicação de logs no CloudWatch Logs consome armazenamento e gera cobranças por esse armazenamento. Se não precisar mais de algum log do CloudWatch, lembre-se de excluí-lo.
1. Escolha **Continue**.
1. Para aplicar as alterações imediatamente, escolha **Immediately (Imediatamente)** na seção **Scheduling of modifications (Programação de modificações)**.
1. Escolha **Modify DB Instance (Modificar instância de banco de dados)** para salvar suas alterações.
## AWS CLI
Para criar uma nova instância de banco de dados com a autenticação do IAM usando a AWS CLI, use o comando [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html). Especifique a opção `--enable-iam-database-authentication`, conforme exibido no exemplo a seguir.
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.m3.medium \
--engine MySQL \
--allocated-storage 20 \
--master-username masterawsuser \
--manage-master-user-password \
--enable-iam-database-authentication
```
Para atualizar uma instância de banco de dados existente a fim de ter ou não autenticação do IAM, use o comando [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) da `modify-db-instance`. Especifique a opção `--enable-iam-database-authentication` ou `--no-enable-iam-database-authentication`, conforme apropriado.
**nota**
Certifique-se de que a instância de banco de dados seja compatível com a autenticação do IAM. Verifique os requisitos de compatibilidade em [Disponibilidade de regiões e versões](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Por padrão, o Amazon RDS modifica a instância de banco de dados durante a próxima janela de manutenção. Se você quiser habilitar a autenticação de banco de dados do IAM o mais rápido possível, use o parâmetro `--apply-immediately`.
Os exemplos a seguir mostram como habilitar imediatamente a autenticação do IAM para uma instância de banco de dados existente.
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--apply-immediately \
--enable-iam-database-authentication
```
Se você está restaurando uma instância de banco de dados, use um dos comandos da AWS CLI a seguir:
+ `[restore-db-instance-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)`
+ `[restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)`
A autenticação de banco de dados do IAM assumirá como padrão aquela do snapshot de origem. Para alterar essa configuração, defina a opção `--enable-iam-database-authentication` ou `--no-enable-iam-database-authentication`, conforme apropriado.
## API do RDS
Para criar uma nova instância de banco de dados com a autenticação do IAM usando a API, use a operação da API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Defina o parâmetro `EnableIAMDatabaseAuthentication` como `true`.
Para atualizar uma instância de banco de dados existente a fim de ter ou não autenticação do IAM, use a operação da API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html). Defina o parâmetro `EnableIAMDatabaseAuthentication` como `true` para habilitar a autenticação do IAM, ou `false` para desabilitá-la.
**nota**
Certifique-se de que a instância de banco de dados seja compatível com a autenticação do IAM. Verifique os requisitos de compatibilidade em [Disponibilidade de regiões e versões](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Se você está restaurando um cluster de de banco de dados, use uma das operações da API a seguir:
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)
A autenticação de banco de dados do IAM assumirá como padrão aquela do snapshot de origem. Para alterar essa configuração, defina o parâmetro `EnableIAMDatabaseAuthentication` como `true` para habilitar a autenticação do IAM, ou `false` para desabilitá-la.
# Criar e usar uma política do IAM para acesso do banco de dados do IAM
Para permitir que um usuário ou um perfil se conecte à instância de banco de dados, você deve criar uma política do IAM. Depois disso, associe a política a um conjunto de permissões ou a um perfil.
**nota**
Para saber mais sobre as políticas do IAM, consulte [Gerenciamento de identidade e acesso no Amazon RDS](UsingWithRDS.IAM.md).
O exemplo de política a seguir permite que um usuário se conecte a uma instância de banco de dados usando a autenticação de banco de dados do IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:db-ABCDEFGHIJKL01234/db_user"
]
}
]
}
```
------
**Importante**
Um usuário com permissões de administrador pode acessar instâncias de banco de dados sem permissões explícitas em uma política do IAM. Se você quiser restringir o acesso do administrador a instâncias de banco de dados, é possível criar um perfil do IAM com as permissões adequadas e menos privilegiadas e atribuí-lo ao administrador.
**nota**
Não confunda o prefixo `rds-db:` com outros prefixos de operações da API do RDS que começam com `rds:`. Você usa o prefixo `rds-db:` e a ação `rds-db:connect` somente para a autenticação de banco de dados do IAM. Eles não são válidos em nenhum outro contexto.
Os exemplos de política incluem uma única instrução com os seguintes elementos:
+ `Effect`: especifica `Allow` para conceder acesso à instância de banco de dados. Se você não permitir explicitamente o acesso, o acesso será negado por padrão.
+ `Action`: especifica `rds-db:connect` para permitir conexões com a instância de banco de dados.
+ `Resource`: especifica um nome do recurso da Amazon (ARN) que descreva uma conta de banco de dados em um instância. de banco de dados. O formato do ARN é o seguinte.
```
arn:aws:rds-db:region:account-id:dbuser:DbiResourceId/db-user-name
```
Neste formato, substitua o seguinte:
+ `region` é a região da AWS para a instância de Bancos de Dados . No exemplo de política, a região da AWS é `us-east-2`.
+ `account-id` é o número da conta da AWS para a instância de Bancos de Dados. No exemplo de política, o número da conta é `1234567890`. O usuário deve estar na mesma conta que a conta da instância de banco de dados.
Para realizar o acesso entre contas, crie um perfil do IAM com a política mostrada acima na conta da instância de banco de dados e permita que sua outra conta assuma o perfil.
+ `DbiResourceId` é o identificador da instância de banco de dados. Esse identificador é exclusivo para uma região da AWS e nunca muda. Na exemplo de política, o identificador é `db-ABCDEFGHIJKL01234`.
Para encontrar um ID de recurso de instância de banco de dados no Console de gerenciamento da AWS do Amazon RDS, escolha a instância de banco de dados para ver os respectivos detalhes. Em seguida, escolha a guia **Configuration (Configuração)**. O **Resource ID (ID de recurso)** é exibido na seção **Configuration (Configuração)**.
Como alternativa, use o comando da AWS CLI para listar os identificadores e os IDs de recurso de todas as suas instâncias de Bancos de Dados na região atual da AWS, conforme mostrado a seguir.
```
aws rds describe-db-instances --query "DBInstances[*].[DBInstanceIdentifier,DbiResourceId]"
```
Se você estiver usando o Amazon Aurora, especifique um `DbClusterResourceId` em vez de um `DbiResourceId`. Para obter mais informações, consulte [Criar e usar uma política do IAM para acesso do banco de dados do IAM](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html) no *Guia do usuário do Amazon Aurora*.
**nota**
Se você estiver se conectando a um banco de dados por meio do RDS Proxy, especifique o ID do recurso de proxy, como `prx-ABCDEFGHIJKL01234`. Para obter informações sobre como usar a autenticação de banco de dados do IAM com RDS Proxy, consulte [Conectar-se a um banco de dados usando autenticação do IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
+ `db-user-name` é o nome da conta de banco de dados para associar à autenticação do IAM. No exemplo de política, a conta de banco de dados é `db_user`.
Você pode criar outros ARNs que sejam compatíveis com vários padrões de acesso. A política a seguir permite o acesso a duas contas de banco de dados diferentes em uma instância de banco de dados.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/jane_doe",
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/mary_roe"
]
}
]
}
```
------
A política a seguir usa o caractere "\$1" para comparar todas as instâncias de Bancos de Dados e todas as contas de banco de dados para uma conta daAWS e uma região específicas da AWS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:*/*"
]
}
]
}
```
------
A política a seguir compara todas as instâncias de Bancos de Dados de uma conta da AWS e uma região da AWS específicas. Contudo, a política concede acesso somente às instâncias de banco de dados que têm uma conta de banco de dados `jane_doe`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:*/jane_doe"
]
}
]
}
```
------
O usuário ou perfil tem acesso apenas aos bancos de dados que o usuário do banco de dados tem. Por exemplo, suponha que sua instância de banco de dados tenha um banco de dados chamado *dev* e outro chamado *test*. Se a usuária do banco de dados `jane_doe` tiver acesso apenas a *dev*, os usuários ou perfis que acessarem essa instância de banco de dados com a usuária `jane_doe` também terão acesso apenas a *dev*. Essa restrição de acesso também é válida para outros objetos de banco de dados, como tabelas, visualizações e assim por diante.
Um administrador deve criar políticas do IAM que concedam às entidades permissões para executar operações de API específicas nos recursos especificados de que precisam. Depois, o administrador deve anexar essas políticas aos conjuntos de permissões e perfis que exigem essas permissões. Para obter exemplos de políticas, consulte [Exemplos de políticas baseadas em identidade do Amazon RDS](security_iam_id-based-policy-examples.md).
## Anexar uma política do IAM a um conjunto de permissões ou perfil
Depois de criar uma política do IAM para permitir a autenticação de banco de dados, você precisa anexar a política a um conjunto de permissões ou a um perfil. Para obter um tutorial sobre esse tópico, consulte [ Criar e anexar sua primeira política gerenciada pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) no *Guia do usuário do IAM*.
À medida que avança pelo tutorial, você pode usar um dos exemplos de política mostrados nessa seção como um ponto de partida e adequá-lo às suas necessidades. No fim do tutorial, você terá um conjunto de permissões com uma política anexada que pode usar a ação `rds-db:connect`.
**nota**
Você pode mapear vários conjuntos de permissões ou perfis para a mesma conta de usuário do banco de dados. Por exemplo, suponha que a sua política do IAM especificou o seguinte recurso do ARN.
```
arn:aws:rds-db:us-east-2:123456789012:dbuser:db-12ABC34DEFG5HIJ6KLMNOP78QR/jane_doe
```
Se você anexar a política a *Jane*, *Bob* e *Diego*, todos eles poderão se conectar à instância de banco de dados em questão usando a conta de banco de dados `jane_doe`.
# Criar uma conta de banco de dados usando autenticação do IAM
Com a autenticação de banco de dados do IAM, você não precisa atribuir senhas de banco de dados à conta de usuário que você criar. Se você remover um usuário que está mapeado a uma conta de banco de dados, também deverá remover a conta de banco de dados com a instrução `DROP USER`.
**nota**
O nome de usuário usado para autenticação do IAM deve corresponder ao caso do nome de usuário no banco de dados.
**Topics**
+ [
## Usar autenticação do IAM com o MariaDB e o MySQL
](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [
## Usar a autenticação do IAM com o PostgreSQL
](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## Usar autenticação do IAM com o MariaDB e o MySQL
Com o MariaDB e o MySQL, a autenticação é processada por `AWSAuthenticationPlugin`: um plug-in fornecido pela AWS que funciona perfeitamente com o IAM para autenticar seus usuários. Conecte-se à instância de banco de dados como usuário principal ou um usuário diferente que possa criar usuários e conceder privilégios. Depois de se conectar, emita a instrução `CREATE USER` conforme mostrado no exemplo a seguir.
```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS';
```
A cláusula `IDENTIFIED WITH` permite que o MariaDB e o MySQL usem o `AWSAuthenticationPlugin` para autenticar a conta de banco de dados (`jane_doe`). A `AS 'RDS'` cláusula refere-se ao método de autenticação. Verifique se o nome do usuário do banco de dados especificado é o mesmo que um recurso na política do IAM para acesso ao banco de dados do IAM. Para obter mais informações, consulte [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md).
**nota**
Se você ver a mensagem a seguir, significa que o plugin fornecido pela AWS não está disponível para a instância de Bancos de Dados atual .
`ERROR 1524 (HY000): Plugin 'AWSAuthenticationPlugin' is not loaded`
Para solucionar esse erro, verifique se você está usando uma configuração compatível e se habilitou a autenticação de banco de dados do IAM em sua instância de banco de dados. Para obter mais informações, consulte [Disponibilidade de regiões e versões](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) e [Habilitar e desabilitar a autenticação de banco de dados do IAM](UsingWithRDS.IAMDBAuth.Enabling.md).
Apos criar uma conta usando `AWSAuthenticationPlugin`, você a gerencia do mesmo modo que as outras contas de banco de dados. Por exemplo, você pode modificar os privilégios da conta com os atributos `GRANT` e `REVOKE`, ou modificar os vários atributos da conta com a instrução `ALTER USER`.
O tráfego de rede do banco de dados é criptografado utilizando SSL/TLS ao usar o IAM. Para permitir conexões SSL, modifique a conta do usuário com o comando a seguir.
```
ALTER USER 'jane_doe'@'%' REQUIRE SSL;
```
## Usar a autenticação do IAM com o PostgreSQL
Para usar a autenticação do IAM com o PostgreSQL, conecte-se à instância de banco de dados como usuário principal ou um usuário diferente que possa criar usuários e conceder privilégios. Depois de conectar-se, crie usuários de banco de dados e, depois, conceda a eles a função `rds_iam` conforme mostrado no exemplo a seguir.
```
CREATE USER db_userx;
GRANT rds_iam TO db_userx;
```
Verifique se o nome do usuário do banco de dados especificado é o mesmo que um recurso na política do IAM para acesso ao banco de dados do IAM. Para obter mais informações, consulte [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Você deve conceder o perfil `rds_iam` para usar a autenticação do IAM. Também é possível usar associações aninhadas ou concessões indiretas do perfil.
# 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).
# Solucionar problemas referentes à autenticação de banco de dados do IAM
A seguir, é possível encontrar ideias de solução de problemas para alguns problemas comuns de autenticação de banco de dados do IAM e informações sobre logs e métricas do CloudWatch para autenticação de banco de dados do IAM.
## Exportar logs de erros de autenticação de banco de dados do IAM para o CloudWatch Logs
Os logs de erros de autenticação de banco de dados do IAM são armazenados no host do banco de dados e podem ser exportados para sua conta do CloudWatch Logs. Use os logs e os métodos de correção nesta página para solucionar problemas de autenticação de banco de dados do IAM.
Você pode habilitar as exportações de log para o CloudWatch Logs por meio do console, da AWS CLI e da API do RDS. Para obter instruções sobre o console, consulte [Publicação de logs de banco de dados no Amazon CloudWatch Logs](USER_LogAccess.Procedural.UploadtoCloudWatch.md).
Para exportar logs de erros de autenticação de banco de dados do IAM para o CloudWatch Logs ao criar uma instância de banco de dados por meio da AWS CLI, use o seguinte comando:
```
aws rds create-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--db-instance-class db.t3.large \
--allocated-storage 50 \
--engine postgres \
--engine-version 16 \
--port 5432 \
--master-username master \
--master-user-password password \
--publicly-accessible \
--enable-iam-database-authentication \
--enable-cloudwatch-logs-exports=iam-db-auth-error
```
Para exportar logs de erros de autenticação de banco de dados do IAM para o CloudWatch Logs ao modificar uma instância de banco de dados por meio da AWS CLI, use o seguinte comando:
```
aws rds modify-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["iam-db-auth-error"]}'
```
Para verificar se a instância de banco de dados está exportando logs de autenticação de banco de dados do IAM para o CloudWatch Logs, confira se o parâmetro `EnabledCloudwatchLogsExports` está definido como `iam-db-auth-error` na saída do comando `describe-db-instances`.
```
aws rds describe-db-instances --region us-east-1 --db-instance-identifier mydbinstance
...
"EnabledCloudwatchLogsExports": [
"iam-db-auth-error"
],
...
```
## Métricas do CloudWatch de autenticação de banco de dados do IAM
O Amazon RDS fornece métricas quase em tempo real sobre a autenticação de banco de dados do IAM para sua conta do Amazon CloudWatch. A seguinte tabela lista as métricas de autenticação de banco de dados do IAM disponíveis usando o CloudWatch:
| Métrica | Descrição |
| --- | --- |
| `IamDbAuthConnectionRequests` | Número total de solicitações de conexão feitas com a autenticação de banco de dados do IAM. |
| `IamDbAuthConnectionSuccess` | Número total de solicitações de autenticação de banco de dados do IAM bem-sucedidas. |
| `IamDbAuthConnectionFailure` | Número total de solicitações de autenticação de banco de dados do IAM malsucedidas. |
| `IamDbAuthConnectionFailureInvalidToken` | Número total de solicitações de autenticação de banco de dados do IAM malsucedidas devido a token inválido. |
| `IamDbAuthConnectionFailureInsufficientPermissions` | Número total de solicitações de autenticação de banco de dados do IAM malsucedidas devido a políticas ou permissões incorretas. |
| `IamDbAuthConnectionFailureThrottling` | Número total de solicitações de autenticação de banco de dados do IAM malsucedidas devido ao controle de utilização da autenticação de banco de dados do IAM. |
| `IamDbAuthConnectionFailureServerError` | Número total de solicitações de autenticação de banco de dados do IAM malsucedidas devido a um erro interno do servidor no recurso de autenticação de banco de dados do IAM. |
## Problemas e soluções comuns de
Você pode encontrar os problemas a seguir ao usar a autenticação de banco de dados do IAM. Use as etapas de correção na tabela para resolver os problemas:
| Erro | Métrica(s) | Causa | Solução |
| --- | --- | --- | --- |
| `[ERROR] Failed to authenticate the connection request for user db_user because the provided token is malformed or otherwise invalid. (Status Code: 400, Error Code: InvalidToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | O token de autenticação de banco de dados do IAM na solicitação de conexão não é um token SigV4a válido ou não está formatado corretamente. | Verifique a estratégia de geração de tokens em sua aplicação. Em alguns casos, observe se você está passando o token com uma formatação válida. Truncar o token (ou formatar incorretamente a string) tornará o token inválido. |
| `[ERROR] Failed to authenticate the connection request for user db_user because the token age is longer than 15 minutes. (Status Code: 400, Error Code:ExpiredToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | O token de autenticação de banco de dados do IAM expirou. Os tokens são válidos somente por 15 minutos. | Verifique a lógica de armazenamento em cache e/ou a reutilização de tokens em sua aplicação. Você não deve reutilizar tokens com mais de 15 minutos. |
| `[ERROR] Failed to authorize the connection request for user db_user because the IAM policy assumed by the caller 'arn:aws:sts::123456789012:assumed-role/ / ' is not authorized to perform `rds-db:connect` on the DB instance. (Status Code: 403, Error Code:NotAuthorized)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInsufficientPermissions` | Esse erro pode ocorrer devido aos seguintes motivos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.Troubleshooting.html) | Verifique o perfil e/ou a política do IAM que você está assumindo em sua aplicação. Você deve assumir a mesma política para gerar o token e para se conectar ao banco de dados. |
| `[ERROR] Failed to authorize the connection request for user db_user due to IAM DB authentication throttling. (Status Code: 429, Error Code: ThrottlingException)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Você está fazendo muitas solicitações de conexão ao banco de dados em um curto espaço de tempo. O limite de controle de utilização da autenticação de banco de dados do IAM é duzentas conexões por segundo. | Reduza a taxa de estabelecimento de novas conexões por meio da autenticação do IAM. Considere implementar o agrupamento de conexões usando o RDS Proxy para reutilizar as conexões estabelecidas em sua aplicação. |
| `[ERROR] Failed to authorize the connection request for user db_user due to an internal IAM DB authentication error. (Status Code: 500, Error Code: InternalError)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Houve um erro interno ao autorizar a conexão do banco de dados com a autenticação de banco de dados do IAM. | Entre em contato com https://aws.amazon.com/premiumsupport/ para investigar o problema. |