# Gerenciamento de identidade e acesso no Amazon RDS
O AWS Identity and Access Management (IAM) é um serviço da AWS service (Serviço da AWS) que ajuda um administrador a controlar com segurança o acesso aos recursos da AWS. Os administradores do IAM controlam quem pode ser *autenticado* (conectado) e *autorizado* (ter permissões) para utilizar os recursos do Amazon RDS. O IAM é um AWS service (Serviço da AWS) que pode ser usado sem custo adicional.
**Topics**
+ [Público](#security_iam_audience)
+ [Autenticar com identidades](#security_iam_authentication)
+ [Gerenciamento do acesso usando políticas](#security_iam_access-manage)
+ [Como o Amazon RDS funciona com o IAM](security_iam_service-with-iam.md)
+ [Exemplos de políticas baseadas em identidade do Amazon RDS](security_iam_id-based-policy-examples.md)
+ [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md)
+ [Atualizações do Amazon RDS para políticas gerenciadas pela AWS](rds-manpol-updates.md)
+ [Prevenção do problema do substituto confuso entre serviços](cross-service-confused-deputy-prevention.md)
+ [Autenticação do banco de dados do IAMpara MariaDB, MySQL e PostgreSQL](UsingWithRDS.IAMDBAuth.md)
+ [Solução de problemas de identidade e acesso do Amazon RDS](security_iam_troubleshoot.md)
## Público
A forma de usar o AWS Identity and Access Management (IAM) varia em função do trabalho realizado no Amazon RDS.
**Usuário do serviço**: se você usar o serviço Amazon RDS para fazer sua tarefa, o administrador fornecerá as credenciais e as permissões de que você precisa. À medida que usar mais recursos do Amazon RDS para fazer seu trabalho, você poderá precisar de permissões adicionais. Entender como o acesso é gerenciado pode ajudar você a solicitar as permissões corretas ao seu administrador. Se não for possível acessar um recurso no Amazon RDS, consulte [Solução de problemas de identidade e acesso do Amazon RDS](security_iam_troubleshoot.md).
**Administrador do serviço**: se você for o responsável pelos recursos do Amazon RDS em sua empresa, você provavelmente terá acesso total ao Amazon RDS. Seu trabalho é determinar quais recursos do Amazon RDS seus funcionários devem acessar. Assim, é necessário enviar solicitações ao administrador do para alterar as permissões dos usuários de seu serviço. Revise as informações nesta página para compreender os conceitos básicos do IAM. Para saber mais sobre como sua empresa pode usar o IAM com o Amazon RDS, consulte [Como o Amazon RDS funciona com o IAM](security_iam_service-with-iam.md).
**Administrador**: se você é um administrador, talvez queira saber detalhes sobre como pode escrever políticas para gerenciar o acesso ao Amazon RDS. Para visualizar exemplos de políticas baseadas em identidade do Amazon RDS que podem ser usadas no IAM, consulte [Exemplos de políticas baseadas em identidade do Amazon RDS](security_iam_id-based-policy-examples.md).
## Autenticar com identidades
A autenticação é a forma como fazer login na AWS usando suas credenciais de identidade. Você precisa se autenticar como o Usuário raiz da conta da AWS, como um usuário do IAM ou assumindo um perfil do IAM.
É possível fazer login como uma identidade federada usando credenciais de uma fonte de identidade, como o Centro de Identidade do AWS IAM (Centro de Identidade do IAM), autenticação única ou credenciais do Google/Facebook. Para ter mais informações sobre como fazer login, consulte [How to sign in to your Conta da AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) no *Guia do usuário do Início de Sessão da AWS*.
Para acesso programático, a AWS oferece um SDK e uma CLI para assinar solicitações criptograficamente. Para ter mais informações, consulte [AWS AWS Signature Version 4 para solicitações de API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) no *Guia do usuário do IAM*.
### Usuário raiz de conta da AWS
Ao criar uma Conta da AWS, você começa com uma única identidade de login chamada *usuário-raiz* da Conta da AWS, que tem acesso total a todos os recursos e Serviços da AWS. É altamente recomendável não usar o usuário-raiz para tarefas diárias. Para ver as tarefas que exigem credenciais de usuário-raiz, consulte [Tarefas que exigem credenciais de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) no *Guia do usuário do IAM*.
### Identidade federada
Como prática recomendada, exija que os usuários humanos usem a federação com um provedor de identidades para acessar a Serviços da AWS usando credenciais temporárias.
*Identidade federada* é um usuário do seu diretório empresarial, de um provedor de identidades da web ou do Directory Service que acessa Serviços da AWS usando credenciais de uma fonte de identidade. As identidades federadas assumem perfis que oferecem credenciais temporárias.
Para o gerenciamento de acesso centralizado, é recomendável usar o Centro de Identidade do AWS IAM. Para obter mais informações, consulte [O que é o IAM Identity Center?](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
### Usuários e grupos do IAM
*[Usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* é uma identidade com permissões específicas a uma única pessoa ou aplicação. Recomendamos usar credenciais temporárias, em vez de usuários do IAM com credenciais de longo prazo. Para obter mais informações, consulte [Exigir que os usuários humanos usem a federação com um provedor de identidade para acessar a AWS usando credenciais temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) no *Guia do usuário do IAM*.
Um [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) especifica um conjunto de usuários do IAM e facilita o gerenciamento de permissões para grandes conjuntos de usuários. Para ter mais informações, consulte [Casos de uso de usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) no *Guia do usuário do IAM*.
Você pode se autenticar na instância de banco de dados usando a autenticação de banco de dados do IAM.
A autenticação do banco de dados do IAM funciona com os seguintes mecanismos de banco de dados:
+ RDS para MariaDB
+ RDS para MySQL
+ RDS para PostgreSQL.
Para obter mais informações sobre a autenticação na instância usando o IAM, consulte [Autenticação do banco de dados do IAMpara MariaDB, MySQL e PostgreSQL](UsingWithRDS.IAMDBAuth.md).
### Perfis do IAM
Um *[perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* é uma identidade na Conta da AWS que tem permissões específicas. Ela é semelhante a um usuário, mas não está associada a uma pessoa específica. É possível presumir temporariamente um perfil do IAM no Console de gerenciamento da AWS [alternando perfis](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html). É possível presumir um perfil chamando uma operação de API da AWS CLI ou da AWS, ou usando um URL personalizado. Para obter mais informações sobre métodos para o uso de perfis, consulte [Utilizar perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) no *Guia do usuário do IAM*.
Funções do IAM com credenciais temporárias são úteis nas seguintes situações:
+ **Permissões temporárias para usuários**: um usuário pode assumir um perfil do IAM para obter temporariamente permissões diferentes para uma tarefa específica.
+ **Acesso de usuário federado**: para atribuir permissões a identidades federadas, é possível criar um perfil e definir permissões para ele. Quando uma identidade federada é autenticada, essa identidade é associada ao perfil e recebe as permissões definidas por ele. Para ter mais informações sobre perfis para federação, consulte [Criar um perfil para um provedor de identidade de terceiros (federação)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) no *Guia do usuário do IAM*. Se usar o Centro de Identidade do IAM, configure um conjunto de permissões. Para controlar o que suas identidades podem acessar após a autenticação, o Centro de Identidade do IAM correlaciona o conjunto de permissões a um perfil no IAM. Para obter informações sobre conjuntos de permissões, consulte [Conjuntos de Permissões](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) no *Guia do Usuário do Centro de Identidade do AWS IAM*.
+ **Acesso entre contas**: é possível usar um perfil do IAM para permitir que alguém (uma entidade principal confiável) em outra conta acesse recursos em sua conta. Os perfis são a principal forma de conceder acesso entre contas. No entanto, alguns Serviços da AWS permitem que você anexe uma política diretamente a um recurso (em vez de usar um perfil como proxy). Para saber a diferença entre perfis e políticas baseadas em recurso para acesso entre contas, consulte [Como os perfis do IAM diferem das políticas baseadas em recurso](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html) no *Guia do usuário do IAM*.
+ **Acesso entre serviços**: alguns Serviços da AWS usam atributos em outros Serviços da AWS. Por exemplo, quando você faz uma chamada em um serviço, é comum que esse serviço execute aplicações no Amazon EC2 ou armazene objetos no Amazon S3. Um serviço pode fazer isso usando as permissões da entidade principal da chamada, usando um perfil de serviço ou um perfil vinculado ao serviço.
+ **Sessões de acesso direto**: as sessões de acesso direto (FAS) usam as permissões da entidade principal chamando um AWS service (Serviço da AWS), além de solicitar que o AWS service (Serviço da AWS) faça solicitações a serviços de downstream. Para obter detalhes da política ao fazer solicitações de FAS, consulte [Sessões de acesso direto](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html).
+ **Perfil de serviço**: um perfil de serviço é um [perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que um serviço assume para executar ações em seu nome. Um administrador do IAM pode criar, modificar e excluir um perfil de serviço do IAM. Para obter mais informações, consulte [Criar um perfil para delegar permissões a um AWS service (Serviço da AWS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do Usuário do IAM*.
+ **Perfil vinculado a serviço**: um perfil vinculado a serviço é um tipo de perfil de serviço vinculado a um AWS service (Serviço da AWS). O serviço pode presumir o perfil para executar uma ação em seu nome. Perfis vinculadas ao serviço aparecem em sua Conta da AWS e são de propriedade do serviço. Um administrador do IAM pode visualizar, mas não editar as permissões para perfis vinculados a serviço.
+ **Aplicações em execução no Amazon EC2**: é possível usar um perfil do IAM para gerenciar credenciais temporárias para aplicações em execução em uma instância do EC2 e fazer solicitações da AWS CLI ou da API da AWS. É preferível fazer isso a armazenar chaves de acesso na instância do EC2. Para atribuir um perfil da AWS a uma instância do EC2 e disponibilizá-la para todas as suas aplicações, crie um perfil de instância que esteja anexado a ela. Um perfil de instância contém o perfil e permite que os programas em execução na instância do EC2 obtenham credenciais temporárias. Para mais informações, consulte [Utilizar um perfil do IAM para conceder permissões a aplicações em execução nas instâncias do Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html) no *Guia do usuário do IAM*.
Para saber se você deve usar perfis do IAM, consulte [Quando criar um perfil do IAM (em vez de um usuário)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose_role) no *Guia do usuário do IAM*.
## Gerenciamento do acesso usando políticas
Você controla o acesso na AWS criando e anexando políticas às identidades do IAM ou aos recursos da AWS. Uma política é um objeto na AWS que, quando associada a uma identidade ou a um recurso, define suas permissões. A AWS avalia essas políticas quando uma entidade (usuário raiz, usuário ou perfil do IAM) faz uma solicitação. As permissões nas políticas determinam se a solicitação será permitida ou negada. A maioria das políticas é armazenada na AWS como documentos JSON. Para obter mais informações sobre a estrutura e o conteúdo de documentos de políticas JSON, consulte [Visão geral das políticas JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) no *Guia do usuário do IAM*.
Um administrador pode usar políticas para especificar quem tem acesso aos recursos da AWS e quais ações essas pessoas podem executar nesses recursos. Cada entidade do IAM (conjunto de permissões ou perfil) começa sem permissões. Em outras palavras, por padrão, os usuários não podem fazer nada, nem mesmo alterar sua própria senha. Para dar permissão a um usuário para fazer algo, um administrador deve anexar uma política de permissões ao usuário. Ou o administrador pode adicionar o usuário a um grupo que tenha as permissões pretendidas. Quando um administrador concede permissões a um grupo, todos os usuários desse grupo recebem essas permissões.
As políticas do IAM definem permissões para uma ação, independentemente do método usado para executar a operação. Por exemplo, suponha que você tenha uma política que permite a ação `iam:GetRole`. Um usuário com essa política pode obter informações de perfis do Console de gerenciamento da AWS, da AWS CLI ou da API AWS.
### Políticas baseadas em identidade
As políticas baseadas em identidade são documentos JSON de políticas de permissões que você pode anexar a uma identidade, como um conjunto de permissões ou um perfil. Essas políticas controlam quais ações cada identidade pode realizar, em quais recursos e em que condições. Para saber como criar uma política baseada em identidade, consulte [Criar políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do usuário do IAM*.
As políticas baseadas em identidade podem ser categorizadas ainda adicionalmente como *políticas em linha* ou *políticas gerenciadas*. As políticas em linha são anexadas diretamente a um único conjunto de permissões ou perfil. As políticas gerenciadas são políticas independentes que podem ser anexadas a vários conjuntos de permissões e perfis em sua conta da AWS. As políticas gerenciadas incluem políticas gerenciadas pela AWS e políticas gerenciadas pelo cliente. Para saber como escolher entre uma política gerenciada ou uma política em linha, consulte [Escolher entre políticas gerenciadas e políticas em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#choosing-managed-or-inline) no *Guia do Usuário do IAM*.
Para obter informações sobre políticas gerenciadas pela AWS específicas do Amazon RDS, consulte [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md).
### Outros tipos de política
A AWS oferece compatibilidade com tipos de política menos comuns. Esses tipos de política podem definir o máximo de permissões concedidas a você pelos tipos de política mais comuns.
+ **Limites de permissões**: um limite de permissões é um recurso avançado no qual você define o máximo de permissões que uma política baseada em identidade pode conceder a uma entidade do IAM (conjunto de permissões ou perfil). É possível definir um limite de permissões para uma entidade. As permissões resultantes são a interseção das políticas baseadas em identidade da entidade e seus limites de permissões. As políticas baseadas em recurso que especificam o conjunto de permissões ou o perfil no campo `Principal` não são limitadas pelo limite de permissões. Uma negação explícita em qualquer uma dessas políticas substitui a permissão. Para obter mais informações sobre limites de permissões, consulte [Limites de permissões para identidades do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) no *Guia do usuário do IAM*.
+ **Políticas de controle de serviço (SCPs)**: SCPs são políticas JSON que especificam as permissões máximas para uma organização ou unidade organizacional (UO) no AWS Organizations. O AWS Organizations é um serviço para agrupar e gerenciar centralmente várias contas da AWS pertencentes à sua empresa. Se você habilitar todos os recursos em uma organização, poderá aplicar políticas de controle de serviço (SCPs) a qualquer uma ou a todas as contas. O SCP limita as permissões para entidades em contas membro, o que inclui cada Usuário raiz da conta da AWS. Para obter mais informações sobre o Organizações e SCPs, consulte [Como os SCPs Funcionam](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html) no *Manual do Usuário do AWS Organizations*.
+ **Políticas de sessão**: são políticas avançadas que você transmite como um parâmetro quando cria de forma programática uma sessão temporária para um perfil ou um usuário federado. As permissões da sessão resultante são a interseção entre as políticas baseadas em identidade dos conjuntos de permissões ou do perfil e as políticas de sessão. As permissões também podem ser provenientes de uma política baseada em recursos. Uma negação explícita em qualquer uma dessas políticas substitui a permissão. Para obter mais informações, consulte [Políticas de sessão](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session) no *Guia do usuário do IAM*.
### Vários tipos de política
Quando vários tipos de política são aplicáveis a uma solicitação, é mais complicado compreender as permissões resultantes. Para saber como a AWS determina se deve permitir ou não uma solicitação quando há vários tipos de política envolvidos, consulte [Lógica da avaliação de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html) no *Guia do usuário do IAM*.
# Como o Amazon RDS funciona com o IAM
Antes de usar o IAM para gerenciar o acesso ao Amazon RDS, você precisa entender quais recursos do IAM estão disponíveis para uso com o Amazon RDS.
A tabela a seguir lista os recursos do IAM que você pode usar com o Amazon RDS:
| Recurso do IAM | Compatibilidade do Amazon RDS |
| --- | --- |
| [Políticas baseadas em identidade](#security_iam_service-with-iam-id-based-policies) | Sim |
| [Políticas baseadas em recurso](#security_iam_service-with-iam-resource-based-policies) | Não |
| [Ações de políticas](#security_iam_service-with-iam-id-based-policies-actions) | Sim |
| [Recursos de políticas](#security_iam_service-with-iam-id-based-policies-resources) | Sim |
| [Chaves de condição de política (específicas do serviço)](#UsingWithRDS.IAM.Conditions) | Sim |
| [ACLs](#security_iam_service-with-iam-acls) | Não |
| [Controle de acesso baseado em atributos (ABAC) (tags em políticas)](#security_iam_service-with-iam-tags) | Sim |
| [Credenciais temporárias](#security_iam_service-with-iam-roles-tempcreds) | Sim |
| [Sessões de acesso direto](#security_iam_service-with-iam-principal-permissions) | Sim |
| [Perfis de serviço](#security_iam_service-with-iam-roles-service) | Sim |
| [Perfis vinculados a serviço](#security_iam_service-with-iam-roles-service-linked) | Sim |
Para obter uma visão de alto nível de como o Amazon RDS e outros serviços da AWS funcionam com o IAM, consulte [Serviços da AWS compatíveis com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.
**Topics**
+ [Políticas baseadas em identidade do Amazon RDS](#security_iam_service-with-iam-id-based-policies)
+ [Políticas baseadas em recursos do Amazon RDS](#security_iam_service-with-iam-resource-based-policies)
+ [Ações de políticas para o Amazon RDS](#security_iam_service-with-iam-id-based-policies-actions)
+ [Recursos de políticas do Amazon RDS](#security_iam_service-with-iam-id-based-policies-resources)
+ [Chaves de condição de políticas do Amazon RDS](#UsingWithRDS.IAM.Conditions)
+ [Listas de controle de acesso (ACLs) no Amazon RDS](#security_iam_service-with-iam-acls)
+ [Controle de acesso baseado em atributos (ABAC) em políticas com tags do Amazon RDS](#security_iam_service-with-iam-tags)
+ [Usar credenciais temporárias com o Amazon RDS](#security_iam_service-with-iam-roles-tempcreds)
+ [Sessões de acesso direto para o Amazon RDS](#security_iam_service-with-iam-principal-permissions)
+ [Perfis de serviço do Amazon RDS](#security_iam_service-with-iam-roles-service)
+ [Funções vinculadas a serviço do Amazon RDS](#security_iam_service-with-iam-roles-service-linked)
## Políticas baseadas em identidade do Amazon RDS
**Compatível com políticas baseadas em identidade:** sim.
As políticas baseadas em identidade são documentos de políticas de permissões JSON que podem ser anexados a uma identidade, como usuário do IAM, grupo de usuários ou perfil. Essas políticas controlam quais ações os usuários e perfis podem realizar, em quais recursos e em que condições. Para saber como criar uma política baseada em identidade, consulte [Definir permissões personalizadas do IAM com as políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do Usuário do IAM*.
Com as políticas baseadas em identidade do IAM, é possível especificar ações e recursos permitidos ou negados, assim como as condições sob as quais as ações são permitidas ou negadas. Para saber mais sobre todos os elementos que podem ser usados em uma política JSON, consulte [Referência de elemento de política JSON do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) no *Guia do usuário do IAM*.
### Exemplos de políticas baseadas em identidade do Amazon RDS
Para visualizar exemplos de políticas baseadas em identidade do Amazon RDS, consulte [Exemplos de políticas baseadas em identidade do Amazon RDS](security_iam_id-based-policy-examples.md).
## Políticas baseadas em recursos do Amazon RDS
**Compatível com políticas baseadas em recursos:** não.
Políticas baseadas em recursos são documentos de políticas JSON que você anexa a um recurso. São exemplos de políticas baseadas em recursos as *políticas de confiança de perfil* do IAM e as *políticas de bucket* do Amazon S3. Em serviços compatíveis com políticas baseadas em recursos, os administradores de serviço podem usá-las para controlar o acesso a um recurso específico. Para o atributo ao qual a política está anexada, a política define quais ações uma entidade principal especificado pode executar nesse atributo e em que condições. É necessário [especificar uma entidade principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) em uma política baseada em recursos. As entidades principais podem incluir contas, usuários, perfis, usuários federados ou Serviços da AWS.
Para permitir o acesso entre contas, é possível especificar uma conta inteira ou as entidades do IAM em outra conta como a entidade principal em uma política baseada em recursos. Consulte mais informações em [Acesso a recursos entre contas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) no *Guia do usuário do IAM*.
## Ações de políticas para o Amazon RDS
**Compatível com ações de políticas:** sim.
Os administradores podem usar as políticas JSON da AWS para especificar quem tem acesso a quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento `Action` de uma política JSON descreve as ações que podem ser usadas para permitir ou negar acesso em uma política. Incluem ações em uma política para conceder permissões para executar a operação associada.
As ações de políticas no Amazon RDS usam o seguinte prefixo antes da ação: `rds:`. Por exemplo, para conceder a alguém permissão para descrever instâncias de banco de dados com a operação da API `DescribeDBInstances` do Amazon RDS, inclua a ação `rds:DescribeDBInstances` na política. As instruções de política devem incluir um elemento `Action` ou `NotAction`. O Amazon RDS define seu próprio conjunto de ações que descrevem as tarefas que você pode executar com esse serviço.
Para especificar várias ações em uma única declaração, separe-as com vírgulas, conforme a seguir.
```
"Action": [
"rds:action1",
"rds:action2"
```
Você também pode especificar várias ações utilizando caracteres curinga (\$1). Por exemplo, para especificar todas as ações que começam com a palavra `Describe`, inclua a ação a seguir:
```
"Action": "rds:Describe*"
```
Para obter uma lista de ações do Amazon RDS, consulte [Ações definidas pelo Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions)* na *Referência de autorização do serviço.
## Recursos de políticas do Amazon RDS
**Compatível com recursos de políticas:** sim.
Os administradores podem usar as políticas JSON da AWS para especificar quem tem acesso a quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento de política JSON `Resource` especifica o objeto ou os objetos aos quais a ação se aplica. Como prática recomendada, especifique um recurso usando seu [nome do recurso da Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Para ações que não oferecem compatibilidade com permissões em nível de recurso, use um curinga (\$1) para indicar que a instrução se aplica a todos os recursos.
```
"Resource": "*"
```
O recurso de instância de banco de dados tem o nome do recurso da Amazon (ARN) a seguir.
```
arn:${Partition}:rds:${Region}:${Account}:{ResourceType}/${Resource}
```
Para obter mais informações sobre o formato de ARNs, consulte [Nomes de recursos da Amazon (ARNs) e namespaces de serviços da AWS](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
Por exemplo, para especificar a instância de banco de dados `dbtest` em sua instrução, use o ARN a seguir.
```
"Resource": "arn:aws:rds:us-west-2:123456789012:db:dbtest"
```
Para especificar todas as instâncias de banco de dados que pertencem a uma conta específica, use o caractere curinga (\$1).
```
"Resource": "arn:aws:rds:us-east-1:123456789012:db:*"
```
Algumas operações da API do RDS, como as operações para a criação de recursos, não podem ser executadas em um recurso específico. Nesses casos, use o caractere curinga (\$1).
```
"Resource": "*"
```
Muitas operações da API do Amazon RDS envolvem vários recursos. Por exemplo, o `CreateDBInstance` cria uma instância de banco de dados. Você pode especificar que um usuário do deve usar um grupo de segurança e um grupo de parâmetros específicos ao criar uma instância de banco de dados. Para especificar vários recursos em uma única declaração, separe os ARNs com vírgulas.
```
"Resource": [
"resource1",
"resource2"
```
Para ver uma lista dos tipos de recursos do Amazon RDS e seus ARNs, consulte [Tipos de recursos definidos pelo Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-resources-for-iam-policies) na *Referência de autorização do serviço*. Para saber com quais ações você pode especificar o ARN de cada recurso, consulte [Ações definidas pelo Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions).
## Chaves de condição de políticas do Amazon RDS
**Compatível com chaves de condição de política específicas de serviço:** sim.
Os administradores podem usar as políticas JSON da AWS para especificar quem tem acesso a quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento `Condition` especifica quando as instruções são executadas com base em critérios definidos. É possível criar expressões condicionais que usem [agentes de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), como “igual a” ou “menor que”, para fazer a condição da política corresponder aos valores na solicitação. Para ver todas as chaves de condição globais da AWS, consulte [Chaves de contexto de condição globais da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
O Amazon RDS define seu próprio conjunto de chaves de condição e também é compatível com o uso de algumas chaves de condição globais. Para ver todas as chaves de condição globais da AWS, consulte [Chaves de contexto de condição globais da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
Todas as operações da API do RDS oferecem suporte à chave de condição `aws:RequestedRegion`.
Para ver uma lista das chaves de condição do Amazon RDS, consulte [Chaves de condição do Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-policy-keys) na *Referência de autorização do serviço*. Para saber com quais ações e recursos você pode usar a chave de condição, consulte [Ações definidas pelo Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions).
## Listas de controle de acesso (ACLs) no Amazon RDS
**Compatível com listas de controle de acesso (ACLs):** não.
As listas de controle de acesso (ACLs) controlam quais entidades principais (membros, usuários ou perfis da conta) têm permissões para acessar um recurso. As ACLs são semelhantes às políticas baseadas em recursos, embora não usem o formato de documento de política JSON.
## Controle de acesso baseado em atributos (ABAC) em políticas com tags do Amazon RDS
**Compatível com tags de controle de acesso baseado em atributos (ABAC) em políticas:** sim.
O controle de acesso por atributo (ABAC) é uma estratégia de autorização que define permissões com base em atributos chamados de tags. Você pode anexar tags a entidades do IAM e recursos da AWS e, em seguida, projetar políticas de ABAC para permitir operações quando a tag da entidade principal corresponder à tag no recurso.
Para controlar o acesso baseado em tags, forneça informações sobre as tags no [elemento de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de uma política usando as `aws:ResourceTag/key-name`, `aws:RequestTag/key-name` ou chaves de condição `aws:TagKeys`.
Se um serviço for compatível com as três chaves de condição para cada tipo de recurso, o valor será **Sim** para o serviço. Se um serviço for compatível com as três chaves de condição somente para alguns tipos de recursos, o valor será **Parcial**
Para saber mais sobre o ABAC, consulte [Definir permissões com autorização do ABAC](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) no *Guia do usuário do IAM*. Para visualizar um tutorial com etapas para configurar o ABAC, consulte [Usar controle de acesso por atributo (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html) no *Guia do usuário do IAM*.
Para obter mais informações sobre recursos de marcação do Amazon RDS, consulte [Especificar condições: usar tags personalizadas](UsingWithRDS.IAM.SpecifyingCustomTags.md). Para visualizar um exemplo de política baseada em identidade para limitar o acesso a um recurso baseado em tags desse recurso, consulte [Conceder permissão para ações em um recurso com uma tag específica com dois valores diferentes](security_iam_id-based-policy-examples-create-and-modify-examples.md#security_iam_id-based-policy-examples-grant-permissions-tags).
## Usar credenciais temporárias com o Amazon RDS
**Compatível com credenciais temporárias:** sim.
As credenciais temporárias dão acesso de curto prazo aos recursos da AWS e são criadas automaticamente quando você usa a federação ou alterna os perfis. A AWS recomenda a você gerar credenciais temporárias dinamicamente, em vez de usar chaves de acesso de longo prazo. Para ter mais informações, consulte [Credenciais de segurança temporárias no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) e [Serviços da Serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.
## Sessões de acesso direto para o Amazon RDS
**Compatível com sessões de acesso direto:** sim.
As sessões de acesso direto (FAS) usam as permissões da entidade principal chamando um AWS service (Serviço da AWS), bem como o AWS service (Serviço da AWS) solicitante, para fazer solicitações a serviços subsequentes. Para obter detalhes da política ao fazer solicitações de FAS, consulte [Sessões de acesso direto](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html).
## Perfis de serviço do Amazon RDS
**Compatível com perfis de serviço:** sim.
O perfil de serviço é um [perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que um serviço assume para executar ações em seu nome. Um administrador do IAM pode criar, modificar e excluir um perfil de serviço do IAM. Para saber mais, consulte [Criar um perfil para delegar permissões a um AWS service (Serviço da AWS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do Usuário do IAM*.
**Atenção**
A alteração das permissões de uma função de serviço pode interromper a funcionalidade do Amazon RDS. Edite perfis de serviço somente quando o Amazon RDS fornecer orientação para isso.
## Funções vinculadas a serviço do Amazon RDS
**Compatível com perfis vinculados a serviços:** sim.
Um perfil vinculado a serviço é um tipo de perfil de serviço vinculado a um AWS service (Serviço da AWS). O serviço pode presumir o perfil de executar uma ação em seu nome. Perfis vinculados ao serviço aparecem em sua Conta da AWS e são de propriedade do serviço. Um administrador do IAM pode visualizar, mas não editar as permissões para perfis vinculados ao serviço.
Para obter detalhes sobre como usar funções vinculadas o serviço do Amazon RDS, consulte [Usar funções vinculadas ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md).
# Exemplos de políticas baseadas em identidade do Amazon RDS
Por padrão, os conjuntos de permissões e perfis não têm permissão para criar nem modificar recursos do Amazon RDS. Eles também não podem executar tarefas usando o Console de gerenciamento da AWS, a AWS CLI ou uma API da AWS. Um administrador deve criar políticas do IAM que concedam aos conjuntos de permissões e perfis permissão 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 saber como criar uma política baseada em identidade do IAM utilizando esses exemplos de documentos de política JSON, consulte [Criar políticas na guia JSON ](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) no *Guia do usuário do IAM*.
**Topics**
+ [Práticas recomendadas de política](#security_iam_service-with-iam-policy-best-practices)
+ [Usar o console do Amazon RDS](#security_iam_id-based-policy-examples-console)
+ [Permissões necessárias para usar o console](#UsingWithRDS.IAM.RequiredPermissions.Console)
+ [Permitir que os usuários visualizem suas próprias permissões](#security_iam_id-based-policy-examples-view-own-permissions)
+ [Políticas de permissão para criar, modificar e excluir recursos no Amazon RDS](security_iam_id-based-policy-examples-create-and-modify-examples.md)
+ [Políticas de exemplo: usar chaves de condição](UsingWithRDS.IAM.Conditions.Examples.md)
+ [Especificar condições: usar tags personalizadas](UsingWithRDS.IAM.SpecifyingCustomTags.md)
+ [Conceder permissão para marcar recursos do Amazon RDS durante a criação](security_iam_id-based-policy-examples-grant-permissions-tags-on-create.md)
## Práticas recomendadas de política
As políticas baseadas em identidade determinam se alguém pode criar, acessar ou excluir recursos do Amazon RDS em sua conta. Essas ações podem incorrer em custos para sua Conta da AWS. Ao criar ou editar políticas baseadas em identidade, siga estas diretrizes e recomendações:
+ **Comece com as políticas gerenciadas pela AWS e avance para as permissões de privilégio mínimo**: para começar a conceder permissões a seus usuários e workloads, use as *políticas gerenciadas pela AWS*, que concedem permissões para muitos casos de uso comuns. Elas estão disponíveis em seus Conta da AWS. Recomendamos que você reduza ainda mais as permissões definindo políticas gerenciadas pelo cliente da AWS que são específicas para seus casos de uso. Para saber mais, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) ou [Políticas gerenciadas pela AWS para funções de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
+ **Aplique permissões de privilégio mínimo**: ao definir permissões com as políticas do IAM, conceda apenas as permissões necessárias para executar uma tarefa. Você faz isso definindo as ações que podem ser executadas em recursos específicos sob condições específicas, também conhecidas como *permissões de privilégio mínimo*. Para saber mais sobre como usar o IAM para aplicar permissões, consulte [Políticas e permissões no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*.
+ **Use condições nas políticas do IAM para restringir ainda mais o acesso**: é possível adicionar uma condição às políticas para limitar o acesso a ações e recursos. Por exemplo, é possível escrever uma condição de política para especificar que todas as solicitações devem ser enviadas usando SSL. Também pode usar condições para conceder acesso a ações de serviço, se elas forem usadas por meio de um AWS service (Serviço da AWS) específico, como o CloudFormation. Para saber mais, consulte [Elementos da política JSON do IAM: condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) no *Guia do usuário do IAM*.
+ **Use o IAM Access Analyzer para validar suas políticas do IAM a fim de garantir permissões seguras e funcionais**: o IAM Access Analyzer valida as políticas novas e existentes para que elas sigam a linguagem de política do IAM (JSON) e as práticas recomendadas do IAM. O IAM Access Analyzer oferece mais de cem verificações de política e recomendações práticas para ajudar a criar políticas seguras e funcionais. Para saber mais, consulte [Validação de políticas do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) no *Guia do Usuário do IAM*.
+ **Exigir autenticação multifator (MFA)**: se houver um cenário que exija usuários do IAM ou um usuário raiz em sua Conta da AWS, ative a MFA para obter segurança adicional. Para exigir MFA quando as operações de API forem chamadas, adicione condições de MFA às suas políticas. Para saber mais, consulte [Configuração de acesso à API protegido por MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) no *Guia do Usuário do IAM*.
Para saber mais sobre as práticas recomendadas do IAM, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
## Usar o console do Amazon RDS
Para acessar o console do Amazon RDS, você deve ter um conjunto mínimo de permissões. Essas permissões devem permitir que você liste e visualize detalhes sobre os recursos do Amazon RDS em sua Conta da AWS. Caso crie uma política baseada em identidade mais restritiva que as permissões mínimas necessárias, o console não funcionará como pretendido para entidades (usuários ou perfis) com essa política.
Não é necessário conceder permissões mínimas do console para usuários que fazem chamadas somente à AWS CLI ou à API do AWS. Em vez disso, permita o acesso somente às ações que corresponderem a operação da API que você estiver tentando executar.
Para garantir que essas entidades ainda possam usar o console do Amazon RDS, anexe também a seguinte política gerenciada pela AWS às entidades.
```
AmazonRDSReadOnlyAccess
```
Para obter mais informações, consulte [Adicionar permissões a um usuário](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) no *Guia do usuário do IAM*.
## Permissões necessárias para usar o console
Para um usuário trabalhar com o console, esse usuário deve ter um conjunto de permissões mínimo. Essas permissões permitem que o usuário descreva os recursos do Amazon RDS para a conta da AWS e forneça outras informações relacionadas, inclusive informações de segurança e rede do Amazon EC2.
Se você criar uma política do IAM que seja mais restritiva que as permissões mínimas necessárias, o console não funcionará como pretendido para os usuários com essa política do IAM. Para garantir que esses usuários ainda consigam usar o console, associe também a política gerenciada `AmazonRDSReadOnlyAccess` ao usuário, conforme descrito em [Gerenciamento do acesso usando políticas](UsingWithRDS.IAM.md#security_iam_access-manage).
Não é necessário conceder permissões mínimas do console para usuários que fazem chamadas somente à AWS CLI ou à API do Amazon RDS.
A seguinte política concede acesso completo a todos os recursos do Amazon RDS para a conta raiz da AWS:
```
AmazonRDSFullAccess
```
## Permitir que os usuários visualizem suas próprias permissões
Este exemplo mostra como criar uma política que permita que os usuários do IAM visualizem as políticas gerenciadas e em linha anexadas a sua identidade de usuário. Essa política inclui permissões para concluir essa ação no console ou de forma programática usando a AWS CLI ou a API da AWS.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
```
# Políticas de permissão para criar, modificar e excluir recursos no Amazon RDS
As seções a seguir apresentam exemplos de políticas de permissão que concedem e restringem o acesso aos recursos:
## Permitir que um usuário crie instâncias de Bancos de Dados em uma conta da AWS
Veja a seguir um exemplo de política que permite à conta com o ID `123456789012` criar instâncias de banco de dados para a sua conta da AWS. A política exige que o nome da nova instância de banco de dados comece com `test`. A nova instância de banco de dados também deve usar o mecanismo de banco de dados MySQL e a classe de instância de banco de dados `db.t2.micro`. Além disso, a nova instância de banco de dados deve usar um grupo de opções e um grupo de parâmetros de banco de dados que começa com `default` e deve usar o grupo de sub-redes `default`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCreateDBInstanceOnly",
"Effect": "Allow",
"Action": [
"rds:CreateDBInstance"
],
"Resource": [
"arn:aws:rds:*:123456789012:db:test*",
"arn:aws:rds:*:123456789012:og:default*",
"arn:aws:rds:*:123456789012:pg:default*",
"arn:aws:rds:*:123456789012:subgrp:default"
],
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": "mysql",
"rds:DatabaseClass": "db.t2.micro"
}
}
}
]
}
```
------
A política inclui uma única instrução que especifica as seguintes permissões para o usuário do :
+ A política permite que a conta crie uma instância de banco de dados usando a operação de API [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) (isso também se aplica ao comando [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) da AWS CLI e ao Console de gerenciamento da AWS).
+ O elemento `Resource` especifica que o usuário pode realizar ações em ou com recursos. Você especifica recursos usando um nome de recurso da Amazon (ARN). O ARN inclui o nome do serviço ao qual o recurso pertence (`rds`), a região da AWS (`*` indica qualquer região neste exemplo), o número de conta da AWS (`123456789012` é o número de conta neste exemplo) e o tipo de recurso. Para obter mais informações sobre como criar ARNs, consulte [Nomes de recurso da Amazon (ARNs) no Amazon RDS](USER_Tagging.ARN.md).
O elemento `Resource` neste exemplo especifica as restrições da política a seguir em recursos para o usuário:
+ O identificador de instância de banco de dados para a nova instância de banco de dados deve começar com `test` (por exemplo, `testCustomerData1`, `test-region2-data`).
+ O grupo de opções para a nova instância de banco de dados deve começar com `default`.
+ O grupo de parâmetros de banco de dados para a nova instância de banco de dados deve começar com `default`.
+ O grupo de sub-redes para a nova instância de banco de dados deve ser o grupo de sub-redes `default`.
+ O elemento `Condition` especifica que o mecanismo de banco de dados deve ser MySQL e a classe da instância de banco de dados deve ser `db.t2.micro`. O elemento `Condition` especifica as condições quando uma política deve entrar em vigor. Você pode adicionar permissões ou restrições usando o elemento `Condition`. Para obter mais informações sobre como especificar condições, consulte [Chaves de condição de políticas do Amazon RDS](security_iam_service-with-iam.md#UsingWithRDS.IAM.Conditions). Este exemplo especifica condições `rds:DatabaseEngine` e `rds:DatabaseClass`. Para obter informações sobre valores de condição válidos para o `rds:DatabaseEngine`, consulte a lista no parâmetro `Engine` em [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Para obter informações sobre os valores de condição válidos para `rds:DatabaseClass`, consulte [Mecanismos de banco de dados compatíveis para classes de instância de banco de dados](Concepts.DBInstanceClass.Support.md) .
A política não especifica o elemento `Principal` porque, em uma política baseada em identidade, não se especifica o principal que obtém as permissões. Quando você anexar uma política um usuário, o usuário será a entidade principal implícita. Quando você anexa uma política de permissão a um perfil do IAM, o principal identificado na política de confiança do perfil obtém as permissões.
Para obter uma lista de ações do Amazon RDS, consulte [Ações definidas pelo Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions)* na *Referência de autorização do serviço.
## Permitir que um usuário execute qualquer ação de descrição em qualquer recurso do RDS
A seguinte política de permissões concede permissões a um usuário para executar todas as ações que começam com `Describe`. Essas ações mostram informações sobre um recurso do RDS, como uma instância de banco de dados. O caractere curinga (\$1) no elemento `Resource` indica que as ações são permitidas para todos os recursos do Amazon RDS que pertencem à conta.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRDSDescribe",
"Effect": "Allow",
"Action": "rds:Describe*",
"Resource": "*"
}
]
}
```
------
## Permitir que um usuário crie uma instância de banco de dados que usa o grupo de parâmetros de banco de dados e o grupo de sub-redes especificados.
A seguinte política de permissões concede permissões para permitir que um usuário crie apenas uma instância de banco de dados que deve usar o grupo de parâmetros de banco de dados `mydbpg` e o grupo de sub-rede de banco de dados `mydbsubnetgroup`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": [
"arn:aws:rds:*:*:pg:mydbpg",
"arn:aws:rds:*:*:subgrp:mydbsubnetgroup"
]
}
]
}
```
------
## Conceder permissão para ações em um recurso com uma tag específica com dois valores diferentes
Você pode usar condições em sua política baseada em identidade para controlar o acesso aos recursos do Amazon RDS com base em tags. A política a seguir concede permissão para realizar a operação de API `CreateDBSnapshot` em instâncias de banco de dados com a etiqueta `stage` definida como `development` ou `test`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowAnySnapshotName",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:snapshot:*"
},
{
"Sid":"AllowDevTestToCreateSnapshot",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
A política a seguir concede permissão para realizar a operação de API `ModifyDBInstance` em instâncias de banco de dados com a etiqueta `stage` definida como `development` ou `test`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowChangingParameterOptionSecurityGroups",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource": [
"arn:aws:rds:*:123456789012:pg:*",
"arn:aws:rds:*:123456789012:secgrp:*",
"arn:aws:rds:*:123456789012:og:*"
]
},
{
"Sid":"AllowDevTestToModifyInstance",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
## Impedir que um usuário exclua uma instância de banco de dados
A seguinte política de permissões concede permissões para impedir que um usuário exclua uma instância de banco de dados específica. Por exemplo, você pode querer negar a capacidade de excluir suas instâncias de banco de dados de produção para qualquer usuário que não seja um administrador.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyDelete1",
"Effect": "Deny",
"Action": "rds:DeleteDBInstance",
"Resource": "arn:aws:rds:us-west-2:123456789012:db:my-mysql-instance"
}
]
}
```
------
## Negar todo o acesso a um recurso
É possível negar acesso explicitamente a um recurso. As políticas de negação têm precedência sobre as políticas de permissão. A política a seguir nega explicitamente a um usuário a capacidade de gerenciar um recurso:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "rds:*",
"Resource": "arn:aws:rds:us-east-1:123456789012:db:mydb"
}
]
}
```
------
# Políticas de exemplo: usar chaves de condição
Os seguintes exemplos mostram como você pode usar chaves de condição em políticas de permissões do IAM do Amazon RDS.
## Exemplo 1: conceder permissão para criar uma instância de banco de dados que usa um mecanismo de banco de dados específico e não é MultiAZ
A seguinte política usa uma chave de condição do RDS e permite que um usuário crie apenas instâncias de banco de dados que usam o mecanismo de banco de dados MySQL e não use o MultiAZ. O elemento `Condition` indica a exigência de que o mecanismo de banco de dados seja MySQL.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowMySQLCreate",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": "mysql"
},
"Bool": {
"rds:MultiAz": false
}
}
}
]
}
```
------
## Exemplo 2: negar explicitamente a permissão para criar instâncias de bancos de dados para determinadas classes de instância de banco de dados e criar instâncias de bancos de dados que usam IOPS provisionadas
A seguinte política nega explicitamente a permissão para criar instâncias de bancos de dados que usam as classes de instância de banco de dados `r3.8xlarge` e `m4.10xlarge`, que são as classes de instância de banco de dados maiores e mais caras. Essa política também impede que os usuários criem instâncias de banco de dados que usam IOPS provisionadas, que resultam em custos adicionais.
A negação explícita da permissão substitui quaisquer outras permissões concedidas. Isso garante que as identidades não obtenham acidentalmente permissão que você nunca deseja conceder.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyLargeCreate",
"Effect": "Deny",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:DatabaseClass": [
"db.r3.8xlarge",
"db.m4.10xlarge"
]
}
}
},
{
"Sid": "DenyPIOPSCreate",
"Effect": "Deny",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"NumericNotEquals": {
"rds:Piops": "0"
}
}
}
]
}
```
------
## Exemplo 3: limitar o conjunto de chaves de tag e valores que podem ser usados para identificar um recurso
A política a seguir usa uma chave de condição do RDS e permite a adição de uma tag com a chave `stage` a ser adicionada a um recurso com os valores `test`, `qa` e `production`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowTagEdits",
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource": "arn:aws:rds:us-east-1:123456789012:db:db-123456",
"Condition": {
"StringEquals": {
"rds:req-tag/stage": [
"test",
"qa",
"production"
]
}
}
}
]
}
```
------
# Especificar condições: usar tags personalizadas
O Amazon RDS oferece suporte para especificar condições em uma política do IAM usando tags personalizadas.
Por exemplo, suponha que você adicione uma tag chamada `environment` às suas instâncias de banco de dados com valores como `beta`, `staging`, `production` e assim por diante. Se fizer isso, você poderá criar uma política que restrinja determinados usuários a instâncias de banco de dados com base no valor da tag `environment`.
**nota**
Os identificadores de tags personalizados diferenciam maiúsculas de minúsculas.
A tabela a seguir lista os identificadores de tags do RDS que você pode usar em um elemento `Condition`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/UsingWithRDS.IAM.SpecifyingCustomTags.html)
A sintaxe de uma condição de tag personalizada é a seguinte:
`"Condition":{"StringEquals":{"rds:rds-tag-identifier/tag-name": ["value"]} }`
Por exemplo, o seguinte elemento `Condition` se aplica a instâncias de banco de dados com uma tag `environment` e um valor de tag de `production`.
` "Condition":{"StringEquals":{"rds:db-tag/environment": ["production"]} } `
Para obter informações sobre como criar tags, consulte [Marcar recursos do do Amazon RDS](USER_Tagging.md).
**Importante**
Se você gerenciar o acesso aos recursos do RDS usando tags, recomendamos proteger o acesso às tags para os seus recursos do RDS. Você pode gerenciar o acesso a tags, criando políticas para as ações `AddTagsToResource` e `RemoveTagsFromResource`. Por exemplo, a seguinte política nega aos usuários a capacidade de adicionar ou remover tags para todos os recursos. Você pode então criar políticas para permitir que usuários específicos adicionem ou removam tags.
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"DenyTagUpdates",
"Effect":"Deny",
"Action":[
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource":"*"
}
]
}
```
Para obter uma lista de ações do Amazon RDS, consulte [Ações definidas pelo Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions)* na *Referência de autorização do serviço.
## Políticas de exemplo: usar tags personalizadas
Os seguintes exemplos mostram como você pode usar tags personalizadas em políticas de permissões do IAM do Amazon RDS. Para obter mais informações sobre como adicionar tags a um recurso do Amazon RDS, consulte [Nomes de recurso da Amazon (ARNs) no Amazon RDS](USER_Tagging.ARN.md).
**nota**
Todos os exemplos usam a região us-west-2 e contêm IDs de conta fictícios.
### Exemplo 1: conceder permissão para ações em um recurso com uma tag específica com dois valores diferentes
A política a seguir concede permissão para realizar a operação de API `CreateDBSnapshot` em instâncias de banco de dados com a etiqueta `stage` definida como `development` ou `test`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowAnySnapshotName",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:snapshot:*"
},
{
"Sid":"AllowDevTestToCreateSnapshot",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
A política a seguir concede permissão para realizar a operação de API `ModifyDBInstance` em instâncias de banco de dados com a etiqueta `stage` definida como `development` ou `test`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowChangingParameterOptionSecurityGroups",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource": [
"arn:aws:rds:*:123456789012:pg:*",
"arn:aws:rds:*:123456789012:secgrp:*",
"arn:aws:rds:*:123456789012:og:*"
]
},
{
"Sid":"AllowDevTestToModifyInstance",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
### Exemplo 2: negar explicitamente a permissão para criar uma instância de banco de dados que usa grupos de parâmetros de banco de dados especificados
A seguinte política nega explicitamente a permissão para criar uma instância de banco de dados que usa grupos de parâmetros de banco de dados com valores de tag específicos. Você poderá aplicar essa política se precisar que um grupo de parâmetros de banco de dados específico criado pelo cliente sempre seja usado ao criar instâncias de bancos de dados. As políticas que utilizam `Deny` são mais frequentemente usadas para restringir o acesso que foi concedido por uma política mais ampla.
A negação explícita da permissão substitui quaisquer outras permissões concedidas. Isso garante que as identidades não obtenham acidentalmente permissão que você nunca deseja conceder.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"DenyProductionCreate",
"Effect":"Deny",
"Action":"rds:CreateDBInstance",
"Resource":"arn:aws:rds:*:123456789012:pg:*",
"Condition":{
"StringEquals":{
"rds:pg-tag/usage":"prod"
}
}
}
]
}
```
------
### Exemplo 3: conceder permissão para executar ações em uma instância de banco de dados com um nome de instância prefixado com um nome de usuário
A seguinte política permite chamar qualquer API (exceto para `AddTagsToResource` ou `RemoveTagsFromResource`) em uma instância de banco de dados que tem um nome prefixado com o nome do usuário e que tem uma tag `stage` igual a `devo` ou sem tag `stage`.
A linha `Resource` na política identifica um recurso pelo seu Nome de Recurso Amazon (ARN). Para obter mais informações sobre como usar ARNs com recursos do Amazon RDS, consulte [Nomes de recurso da Amazon (ARNs) no Amazon RDS](USER_Tagging.ARN.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowFullDevAccessNoTags",
"Effect":"Allow",
"NotAction":[
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource":"arn:aws:rds:*:123456789012:db:${aws:username}*",
"Condition":{
"StringEqualsIfExists":{
"rds:db-tag/stage":"devo"
}
}
}
]
}
```
------
# Conceder permissão para marcar recursos do Amazon RDS durante a criação
Algumas operações de API do RDS permitem atribuir tags ao criar recursos. É possível usar tags de recursos para implementar o controle baseado em atributo (ABAC). Para ter mais informações, consulte [What is ABAC for AWS?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) e [Controlar o acesso a recursos da AWS usando tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html).
Para permitir que os usuários marquem recursos na criação, eles devem ter permissões para usar a ação que cria o recurso, como `rds:CreateDBInstance`. Se as tags forem especificadas no ato da criação, o RDS concederá uma autorização adicional na ação `rds:AddTagsToResource` para verificar se os usuários têm permissões para criar tags. Portanto, os usuários também precisam ter permissões para usar a ação `rds:AddTagsToResource`.
Na definição de política do IAM para a ação `rds:AddTagsToResource`, você pode usar a chave de condição `aws:RequestTag` para exigir tags em uma solicitação para marcar um recurso.
Por exemplo, a seguinte política permite que os usuários criem instâncias de banco de dados e apliquem tags durante a criação, mas somente com chaves de tag específicas (`environment` ou `project`):
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds:CreateDBInstance"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": ["production", "development"],
"aws:RequestTag/project": ["dataanalytics", "webapp"]
},
"ForAllValues:StringEquals": {
"aws:TagKeys": ["environment", "project"]
}
}
}
]
}
```
------
Essa política nega qualquer solicitação de criação de instância de banco de dados que inclua tags diferentes das tags `environment` ou `project` ou que não especifique nenhuma dessas tags. Além disso, os usuários devem especificar valores para as tags que correspondam aos valores permitidos na política.
A seguinte política permite que os usuários criem clusters de banco de dados e apliquem qualquer tag durante a criação, exceto a tag `environment=prod`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds:CreateDBCluster"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:RequestTag/environment": "prod"
}
}
}
]
}
```
------
## Ações de API do RDS que permitem atribuir tags durante a criação
As ações de API do RDS a seguir permitem atribuir tags durante a criação de um recurso. Para estas ações, você pode atribuir tags ao criar o recurso:
+ `CreateBlueGreenDeployment`
+ `CreateCustomDBEngineVersion`
+ `CreateDBCluster`
+ `CreateDBClusterEndpoint`
+ `CreateDBClusterParameterGroup`
+ `CreateDBClusterSnapshot`
+ `CreateDBInstance`
+ `CreateDBInstanceReadReplica`
+ `CreateDBParameterGroup`
+ `CreateDBProxy`
+ `CreateDBProxyEndpoint`
+ `CreateDBSecurityGroup`
+ `CreateDBShardGroup`
+ `CreateDBSnapshot`
+ `CreateDBSubnetGroup`
+ `CreateEventSubscription`
+ `CreateGlobalCluster`
+ `CreateIntegration`
+ `CreateOptionGroup`
+ `CreateTenantDatabase`
+ `CopyDBClusterParameterGroup`
+ `CopyDBClusterSnapshot`
+ `CopyDBParameterGroup`
+ `CopyDBSnapshot`
+ `CopyOptionGroup`
+ `RestoreDBClusterFromS3`
+ `RestoreDBClusterFromSnapshot`
+ `RestoreDBClusterToPointInTime`
+ `RestoreDBInstanceFromDBSnapshot`
+ `RestoreDBInstanceFromS3`
+ `RestoreDBInstanceToPointInTime`
+ `PurchaseReservedDBInstancesOffering`
Se você usar a AWS CLI ou a API para criar um recurso com tags, o parâmetro `Tags` será usado para aplicar tags aos recursos durante a criação.
Para essas ações de API, se a atribuição de tags falhar, o recurso não será criado e a solicitação falhará e apresentará um erro. Isso garante que os recursos sejam criados com tags ou não sejam criados, o que evita a criação de recursos sem as tags pretendidas.
# AWSPolíticas gerenciadas pela para o Amazon RDS
Para adicionar permissões a conjuntos de permissões e perfis, é mais fácil usar políticas gerenciadas pela AWS do que elaborar políticas por conta própria. É necessário tempo e experiência para [criar políticas gerenciadas pelo cliente do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) que fornecem à sua equipe apenas as permissões de que precisam. Para começar rapidamente, você pode usar nossas políticas gerenciadas pela AWS. Essas políticas abrangem casos de uso comuns e estão disponíveis na sua Conta da AWS. Para ter mais informações sobre as políticas gerenciadas da AWS, consulte [Políticas gerenciadas da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Guia do usuário do IAM*.
Os Serviços da AWS mantêm e atualizam políticas gerenciadas pela AWS. Não é possível alterar as permissões em políticas gerenciadas pela AWS. Os serviços ocasionalmente acrescentam permissões adicionais a uma política gerenciada pela AWS para oferecer compatibilidade com novos atributos. Esse tipo de atualização afeta todas as identidades (conjuntos de permissões e perfis) às quais a política está anexada. É mais provável que os serviços atualizem uma política gerenciada pela AWS quando um novo atributo for iniciado ou novas operações se tornarem disponíveis. Os serviços não removem permissões de uma política gerenciada pela AWS. Portanto, as atualizações de políticas não suspendem suas permissões atuais.
Além disso, a AWS oferece suporte a políticas gerenciadas para funções de trabalho que abrangem vários serviços. Por exemplo, a política `ReadOnlyAccess` gerenciada pela AWS concede acesso somente leitura a todos os recursos e Serviços da AWS. Quando um serviço executa um novo recurso, a AWS adiciona permissões somente leitura para novas operações e recursos. Para obter uma lista e descrições das políticas de perfis de trabalho, consulte [Políticas gerenciadas pela AWS para perfis de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
**Topics**
+ [AWSPolítica gerenciada pela : AmazonRDSReadOnlyAccess](#rds-security-iam-awsmanpol-AmazonRDSReadOnlyAccess)
+ [AWSPolítica gerenciada pela : AmazonRDSFullAccess](#rds-security-iam-awsmanpol-AmazonRDSFullAccess)
+ [AWSPolítica gerenciada pela : AmazonRDSDataFullAccess](#rds-security-iam-awsmanpol-AmazonRDSDataFullAccess)
+ [AWSPolítica gerenciada pela : AmazonRDSEnhancedMonitoringRole](#rds-security-iam-awsmanpol-AmazonRDSEnhancedMonitoringRole)
+ [AWSPolítica gerenciada pela : AmazonRDSPerformanceInsightsReadOnly](#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsReadOnly)
+ [Política gerenciada pela AWS: AmazonRDSPerformanceInsightsFullAccess](#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsFullAccess)
+ [AWSPolítica gerenciada pela : AmazonRDSDirectoryServiceAccess](#rds-security-iam-awsmanpol-AmazonRDSDirectoryServiceAccess)
+ [AWSPolítica gerenciada pela : AmazonRDSServiceRolePolicy](#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy)
+ [AWSPolítica gerenciada pela : AmazonRDSCustomServiceRolePolicy](#rds-security-iam-awsmanpol-AmazonRDSCustomServiceRolePolicy)
+ [Política gerenciada da AWS: AmazonRDSCustomInstanceProfileRolePolicy](#rds-security-iam-awsmanpol-AmazonRDSCustomInstanceProfileRolePolicy)
+ [Política gerenciada da AWS: AmazonRDSPreviewServiceRolePolicy](#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy)
+ [Política gerenciada da AWS: AmazonRDSBetaServiceRolePolicy](#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy)
## AWSPolítica gerenciada pela : AmazonRDSReadOnlyAccess
Essa política permite o acesso somente leitura ao Amazon RDS por meio do Console de gerenciamento da AWS.
**Detalhes de permissões**
Esta política inclui as seguintes permissões:
+ `rds`: permite que as entidades principais descrevam os recursos do Amazon RDS e listem as etiquetas dos respectivos recursos.
+ `cloudwatch`: permite que as entidades principais obtenham estatísticas de métricas do Amazon CloudWatch.
+ `ec2`: permite que as entidades principais descrevam zonas de disponibilidade e recursos de rede.
+ `logs`: permite que as entidades principais descrevam fluxos de log do CloudWatch Logs de grupos de logs e obtenham eventos de log do CloudWatch Logs.
+ `devops-guru`: permite que as entidades principais descrevam os recursos que têm cobertura do Amazon DevOps Guru, que é especificada pelos nomes das pilhas ou pelas tags de recursos do CloudFormation.
Para ter mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSReadOnlyAccess.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## AWSPolítica gerenciada pela : AmazonRDSFullAccess
Essa política concede acesso total ao Amazon RDS por meio do Console de gerenciamento da AWS.
**Detalhes de permissões**
Esta política inclui as seguintes permissões:
+ `rds`: concede às entidades principais acesso total ao Amazon RDS.
+ `application-autoscaling`: permite que as entidades principais descrevam e gerenciem destinos e políticas de escalabilidade do Application Auto Scaling.
+ `cloudwatch`: permite que as entidades principais obtenham estáticas de métricas do CloudWatch e gerenciem os respectivos alarmes.
+ `ec2`: permite que as entidades principais descrevam zonas de disponibilidade e recursos de rede.
+ `logs`: permite que as entidades principais descrevam fluxos de log do CloudWatch Logs de grupos de logs e obtenham eventos de log do CloudWatch Logs.
+ `outposts`: permite que as entidades principais obtenham tipos de instância AWS Outposts.
+ `pi`: permite que as entidades principais obtenham métricas do Performance Insights.
+ `sns`: permite que as entidades principais acessem assinaturas e tópicos do Amazon Simple Notification Service (Amazon SNS) e publiquem mensagens do Amazon SNS.
+ `devops-guru`: permite que as entidades principais descrevam os recursos que têm cobertura do Amazon DevOps Guru, que é especificada pelos nomes das pilhas ou pelas tags de recursos do CloudFormation.
Para ter mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSFullAccess.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## AWSPolítica gerenciada pela : AmazonRDSDataFullAccess
Essa política permite acesso total ao uso da API DATA e ao editor de consultas em clusters do Aurora Serverless em uma Conta da AWS específica. Essa política permite que a Conta da AWS obtenha o valor de um segredo do AWS Secrets Manager.
É possível anexar a política `AmazonRDSDataFullAccess` às suas identidades do IAM.
**Detalhes de permissões**
Esta política inclui as seguintes permissões:
+ `dbqms`: permite que as entidades principais acessem, criem, excluam, descrevam e atualizem consultas. O Database Query Metadata Service (`dbqms`) é um serviço somente interno. Ele fornece suas consultas recentes e salvas para o editor de consultas no Console de gerenciamento da AWS para vários Serviços da AWS, inclusive o Amazon RDS.
+ `rds-data`: permite que as entidades principais executem instruções SQL em bancos de dados do Aurora Serverless.
+ `secretsmanager` – permite que as entidades principais obtenham o valor de um segredo do AWS Secrets Manager.
Para ter mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSDataFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSDataFullAccess.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## AWSPolítica gerenciada pela : AmazonRDSEnhancedMonitoringRole
Essa política fornece acesso ao Amazon CloudWatch Logs for Amazon RDS Enhanced Monitoring.
**Detalhes de permissões**
Esta política inclui as seguintes permissões:
+ `logs`: permite que as entidades principais criem grupos de logs e políticas de retenção do CloudWatch Logs, bem como criem e descrevam fluxos de log do CloudWatch Logs de grupos de logs. Ela também permite que as entidades principais insiram e obtenham eventos de log do CloudWatch Logs.
Para ter mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSEnhancedMonitoringRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSEnhancedMonitoringRole.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## AWSPolítica gerenciada pela : AmazonRDSPerformanceInsightsReadOnly
Essa política fornece acesso somente leitura ao Insights de Performance do Amazon RDS para instâncias de banco de dados do Amazon RDS e de clusters de banco de dados do Amazon Aurora.
Essa política agora inclui `Sid` (ID da instrução) como identificador para a declaração de política.
**Detalhes de permissões**
Esta política inclui as seguintes permissões:
+ `rds`: permite que as entidades principais descrevam instâncias de banco de dados do Amazon RDS e de clusters de banco de dados Amazon Aurora
+ `pi`: permite que as entidades principais façam chamadas para a API do Insights de Performance do Amazon RDS e acessem as métricas do Insights de Performance.
Para ter mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSPerformanceInsightsReadOnly](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPerformanceInsightsReadOnly.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## Política gerenciada pela AWS: AmazonRDSPerformanceInsightsFullAccess
Essa política fornece acesso total ao Insights de Performance do Amazon RDS para instâncias de banco de dados do Amazon RDS e clusters de banco de dados do Amazon Aurora.
Essa política agora inclui `Sid` (ID da instrução) como identificador para a declaração de política.
**Detalhes de permissões**
Esta política inclui as seguintes permissões:
+ `rds`: permite que as entidades principais descrevam instâncias de banco de dados do Amazon RDS e de clusters de banco de dados Amazon Aurora
+ `pi`: permite que as entidades principais façam chamadas para a API do Insights de Performance do Amazon RDS e criem, visualizem e excluam relatórios de análise de performance.
+ `cloudwatch`: permite que as entidades principais listem métricas do Amazon CloudWatch e obtenham dados de métricas e estatística.
Para receber mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSPerformanceInsightsFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPerformanceInsightsFullAccess.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## AWSPolítica gerenciada pela : AmazonRDSDirectoryServiceAccess
Essa política permite que o Amazon RDS faça chamadas ao Directory Service.
**Detalhes relacionados às permissões**
Esta política inclui a seguinte permissão:
+ `ds`: permite que as entidades principais descrevam diretórios do Directory Service e controlem a autorização para diretórios do Directory Service.
Para ter mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSDirectoryServiceAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSDirectoryServiceAccess.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## AWSPolítica gerenciada pela : AmazonRDSServiceRolePolicy
Não é possível anexar a política `AmazonRDSServiceRolePolicy` às suas entidades do IAM. Essa política é anexada a uma função vinculada ao serviço que permite ao Amazon RDS realizar ações em seu nome. Para ter mais informações, consulte [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions).
## AWSPolítica gerenciada pela : AmazonRDSCustomServiceRolePolicy
Não é possível anexar a política `AmazonRDSCustomServiceRolePolicy` às suas entidades do IAM. Essa política é anexada a um perfil vinculado ao serviço que permite ao Amazon RDS chamar serviços da AWS em nome de seus recursos de banco de dados do RDS.
Esta política inclui as seguintes permissões:
+ `ec2`: permite que o RDS Custom execute operações de backup na instância de banco de dados que fornece recursos de restauração para um ponto no tempo.
+ `secretsmanager`: permite que o RDS Custom gerencie segredos específicos da instância de banco de dados criados pelo RDS Custom.
+ `cloudwatch`: permite que o RDS Custom faça upload de métricas e de logs da instância de banco de dados no CloudWatch por meio do agente do CloudWatch.
+ `events`, `sqs`: permite que o RDS Custom envie e receba informações de status sobre a instância de banco de dados.
+ `cloudtrail`: permite que o RDS Custom receba eventos de alteração sobre a instância de banco de dados.
+ `servicequotas`: permite que o RDS Custom leia cotas de serviço relacionadas à instância de banco de dados.
+ `ssm`: permite que o RDS Custom gerencie a instância subjacente do EC2 da instância de banco de dados.
+ `rds`: permite que o RDS Custom gerencie recursos do RDS para sua instância de banco de dados.
+ `iam`: permite que o RDS Custom valide e anexe o perfil de instância à instância subjacente do EC2 de uma instância de banco de dados.
Para ter mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSCustomServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSCustomServiceRolePolicy.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## Política gerenciada da AWS: AmazonRDSCustomInstanceProfileRolePolicy
Não é possível anexar `AmazonRDSCustomInstanceProfileRolePolicy` às suas entidades do IAM. Ele só deve ser anexado a uma função de perfil de instância usada para conceder permissões à instância de banco de dados do Amazon RDS Custom para realizar várias ações de automação e tarefas de gerenciamento de banco de dados. Passe o perfil de instância como o parâmetro `custom-iam-instance-profile` durante a criação da instância personalizada do RDS e o RDS Custom associará esse perfil à instância de banco de dados.
**Detalhes de permissões**
Esta política inclui as seguintes permissões:
+ `ssm`, `ssmmessages`, `ec2messages`: permite que o RDS Custom se comunique, execute automação e mantenha agentes na instância de banco de dados por meio do Systems Manager.
+ `ec2`, `s3`: permite que o RDS Custom execute operações de backup na instância de banco de dados que fornece recursos de restauração pontuais.
+ `secretsmanager`: permite que o RDS Custom gerencie segredos específicos da instância de banco de dados criados pelo RDS Custom.
+ `cloudwatch`, `logs`: permite que o RDS Custom faça upload de métricas e logs da instância de banco de dados no CloudWatch por meio do agente do CloudWatch.
+ `events`, `sqs`: permite que o RDS Custom envie e receba informações de status sobre a instância de banco de dados.
+ `kms`: permite que o RDS Custom use uma chave do KMS específica da instância para realizar a criptografia de segredos e objetos do S3 gerenciados pelo RDS Custom.
Para receber mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSCustomInstanceProfileRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSCustomInstanceProfileRolePolicy.html) no *Guia de referência de políticas gerenciadas da AWS*.
## Política gerenciada da AWS: AmazonRDSPreviewServiceRolePolicy
Não é possível anexar `AmazonRDSPreviewServiceRolePolicy` às suas entidades do IAM. Essa política é anexada a um perfil vinculado ao serviço que permite ao Amazon RDS chamar serviços da AWS em nome de seus recursos de banco de dados do RDS. Para obter mais informações, consulte [Perfil vinculado ao serviço da Pré-visualização do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-rdspreview).
**Detalhes de permissões**
Esta política inclui as seguintes permissões:
+ `ec2`: permite que as entidades principais descrevam Zonas de Disponibilidade e recursos de rede.
+ `secretsmanager` – permite que as entidades principais obtenham o valor de um segredo do AWS Secrets Manager.
+ `cloudwatch`, `logs`: permite que o Amazon RDS faça upload de métricas e logs da instância de banco de dados no CloudWatch por meio do agente do CloudWatch.
Para ter mais informações sobre essa política, bem como o documento de política JSON, consulte [AmazonRDSPreviewServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPreviewServiceRolePolicy.html) no *Guia de referência de políticas gerenciadas da AWS*.
## Política gerenciada da AWS: AmazonRDSBetaServiceRolePolicy
Não é possível anexar `AmazonRDSBetaServiceRolePolicy` às suas entidades do IAM. Essa política é anexada a um perfil vinculado ao serviço que permite ao Amazon RDS chamar serviços da AWS em nome de seus recursos de banco de dados do RDS. Para obter mais informações, consulte [Permissões de perfis vinculados ao serviço para o Amazon RDS Beta](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-rdsbeta).
**Detalhes de permissões**
Esta política inclui as seguintes permissões:
+ `ec2`: permite que o Amazon RDS execute operações de backup na instância de banco de dados que fornece recursos de restauração para um ponto no tempo.
+ `secretsmanager`: permite ao Amazon RDS gerenciar segredos específicos da instância de banco de dados criados pelo Amazon RDS.
+ `cloudwatch`, `logs`: permite que o Amazon RDS faça upload de métricas e logs da instância de banco de dados no CloudWatch por meio do agente do CloudWatch.
Para ter mais informações sobre essa política, incluindo o documento de política JSON, consulte [AmazonRDSBetaServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSBetaServiceRolePolicy.html) no *Guia de referência de políticas gerenciadas da AWS*.
# Atualizações do Amazon RDS para políticas gerenciadas pela AWS
Visualize detalhes sobre atualizações em políticas gerenciadas pela AWS para o Amazon RDS desde que esse serviço começou a monitorar essas alterações. Para receber alertas automáticos sobre mudanças nesta página, assine o feed RSS na página [Histórico de documentos](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/WhatsNew.html) do Amazon RDS.
| Alteração | Descrição | Data |
| --- | --- | --- |
| [Política gerenciada da AWS: AmazonRDSPreviewServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy): atualizar para uma política existente. | O Amazon RDS removeu a permissão `sns:Publish` da `AmazonRDSPreviewServiceRolePolicy` do perfil vinculado ao serviço `AWSServiceRoleForRDSPreview`. Para ter mais informações, consulte [Política gerenciada da AWS: AmazonRDSPreviewServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy). | 7 de agosto de 2024 |
| [Política gerenciada da AWS: AmazonRDSBetaServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy): atualizar para uma política existente. | O Amazon RDS removeu a permissão `sns:Publish` da `AmazonRDSBetaServiceRolePolicy` do perfil vinculado ao serviço `AWSServiceRoleForRDSBeta`. Para ter mais informações, consulte [Política gerenciada da AWS: AmazonRDSBetaServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy). | 7 de agosto de 2024 |
| [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom): atualizar para uma política existente. | O Amazon RDS adicionou novas permissões à `AmazonRDSCustomServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDSCustom`. As permissões possibilitam que o RDS Custom se comunique com os serviços do Amazon RDS em outra Região da AWS e copie imagens do EC2. Para ter mais informações, consulte [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 18 de julho de 2024 |
| [AWSPolítica gerenciada pela : AmazonRDSServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy): atualizar para uma política existente. | O Amazon RDS removeu a permissão `sns:Publish` da `AmazonRDSServiceRolePolicy` do perfil vinculado ao serviço ` AWSServiceRoleForRDS`. Para ter mais informações, consulte [AWSPolítica gerenciada pela : AmazonRDSServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy). | 2 de julho de 2024 |
| [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom): atualizar para uma política existente. | O Amazon RDS adicionou novas permissões à `AmazonRDSCustomServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDSCustom`. Essa nova permissão permite que o RDS Custom associe um perfil de serviço como um perfil de instância a uma instância do RDS Custom. Para ter mais informações, consulte [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 19 de abril de 2024 |
| [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md): atualizar para uma política existente. | O Amazon RDS adicionou uma nova permissão ao `AmazonRDSCustomServiceRolePolicy` do perfil vinculado ao serviço `AWSServiceRoleForRDSCustom` para permitir que o RDS Custom para SQL Server modifique o tipo de instância de host do banco de dados subjacente. O RDS também adicionou a permissão `ec2:DescribeInstanceTypes` para receber informações sobre o tipo de instância para o host do banco de dados. Para ter mais informações, consulte [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md). | 8 de abril de 2024 |
| [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md) – Nova política | O Amazon RDS adicionou uma nova política gerenciada chamada AmazonRDSCustomInstanceProfileRolePolicy para permitir que o RDS Custom execute ações de automação e tarefas de gerenciamento de banco de dados por meio de um perfil de instância do EC2. Para ter mais informações, consulte [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md). | 27 de fevereiro de 2024 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novos IDs de declarações à `AmazonRDSServiceRolePolicy` do perfil vinculado ao serviço `AWSServiceRoleForRDS`. Para ter mais informações, consulte [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions). | 19 de janeiro de 2024 |
| [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md): atualizações em políticas existentes. | As políticas `AmazonRDSPerformanceInsightsFullAccess` gerenciadas `AmazonRDSPerformanceInsightsReadOnly` e as políticas agora incluem `Sid` (ID da instrução) como identificador na declaração de política. Para obter mais informações, consulte [AWSPolítica gerenciada pela : AmazonRDSPerformanceInsightsReadOnly](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsReadOnly) e [Política gerenciada pela AWS: AmazonRDSPerformanceInsightsFullAccess](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsFullAccess). | 23 de outubro de 2023 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novas permissões à `AmazonRDSCustomServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDSCustom`. Essas novas permissões possibilitam que o RDS Custom para Oracle crie, modifique e exclua regras gerenciadas do EventBridge. Para ter mais informações, consulte [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 20 de setembro de 2023 |
| [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md): atualizar para uma política existente. | O Amazon RDS adicionou novas permissões à política gerenciada `AmazonRDSFullAccess`. As permissões autorizam que você gere, visualize e exclua o relatório de análise de performance por um período. Para receber mais informações sobre como configurar políticas de acesso para o Insights de Performance, consulte [Configurar políticas de acesso para o Performance Insights](USER_PerfInsights.access-control.md). | 17 de agosto de 2023 |
| [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md): nova política e atualização da política existente. | O Amazon RDS adicionou novas permissões à política gerenciada `AmazonRDSPerformanceInsightsReadOnly` e uma nova política gerenciada chamada `AmazonRDSPerformanceInsightsFullAccess`. Essas permissões autorizam que você analise o Insights de Performance por um período, visualize os resultados da análise com as recomendações e exclua os relatórios. Para receber mais informações sobre como configurar políticas de acesso para o Insights de Performance, consulte [Configurar políticas de acesso para o Performance Insights](USER_PerfInsights.access-control.md). | 16 de agosto de 2023 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novas permissões à `AmazonRDSCustomServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDSCustom`. Essas novas permissões possibilitam que o RDS Custom para Oracle utilize snapshots de banco de dados. Para ter mais informações, consulte [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 23 de junho de 2023 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novas permissões à `AmazonRDSCustomServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDSCustom`. Essas novas permissões possibilitam que o RDS Custom para Oracle utilize snapshots de banco de dados. Para ter mais informações, consulte [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 23 de junho de 2023 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novas permissões à `AmazonRDSCustomServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDSCustom`. Essas novas permissões possibilitam que o RDS Custom crie interfaces de rede. Para ter mais informações, consulte [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 30 de maio de 2023 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novas permissões à `AmazonRDSCustomServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDSCustom`. Essas novas permissões permitem que o RDS Custom chame o Amazon EBS para conferir a cota de armazenamento. Para ter mais informações, consulte [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 18 de abril de 2023 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS Custom adicionou novas permissões a `AmazonRDSCustomServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDSCustom` para integração com o Amazon SQS. O RDS Custom requer integração com o Amazon SQS para criar e gerenciar filas do SQS na conta do cliente. Os nomes das filas do SQS seguem o formato `do-not-delete-rds-custom-[identifier]` e são marcados com `Amazon RDS Custom`. A permissão para `ec2:CreateSnapshot` foi adicionada para permitir que o RDS Custom crie backups para volumes anexados à instância. Para ter mais informações, consulte [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 6 de abril de 2023 |
| [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md): atualizar para uma política existente | O Amazon RDS adicionou um novo namespace do Amazon CloudWatch `ListMetrics` a `AmazonRDSFullAccess` e a `AmazonRDSReadOnlyAccess`. Esse namespace é necessário para que o Amazon RDS liste métricas específicas de uso de recursos. Para ter mais informações, consulte [Visão geral do gerenciamento de permissões de acesso aos recursos do CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-access-control-overview-cw.html) no *Guia do usuário do Amazon CloudWatch*. | 4 de abril de 2023 |
| [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md): atualizar para uma política existente | O Amazon RDS adicionou uma nova permissão a `AmazonRDSFullAccess` e às políticas gerenciadas `AmazonRDSReadOnlyAccess` para possibilitar a exibição das descobertas do Amazon DevOps Guru no console do RDS. Essa permissão é necessária para possibilitar a exibição das descobertas do DevOps Guru. Para ter mais informações, consulte [ Atualizações do Amazon RDS para políticas gerenciadas pela AWS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-manpol-updates.html). | 30 de março de 2023 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novas permissões à `AmazonRDSServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDS` para integração com o AWS Secrets Manager. O RDS requer integração com o Secrets Manager para gerenciar senhas do usuário principal no Secrets Manager. O segredo usa uma convenção de nomenclatura reservada e restringe as atualizações do cliente. Para ter mais informações, consulte [Gerenciamento de senhas com Amazon RDS e AWS Secrets Manager](rds-secrets-manager.md). | 22 de dezembro de 2022 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novas permissões à `AmazonRDSCustomServiceRolePolicy` da função vinculada ao serviço `AWSServiceRoleForRDSCustom`. O RDS Custom é compatível com clusters de banco de dados. Essas novas permissões na política permitem que o RDS Custom chame Serviços da AWS em nome de seus clusters de banco de dados. Para ter mais informações, consulte [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 9 de novembro de 2022 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novas permissões ao perfil vinculado ao serviço `AWSServiceRoleForRDS` para integração com o AWS Secrets Manager. A integração com o Secrets Manager é necessária para que o SQL Server Reporting Services (SSRS) Email funcione no RDS. O SSRS Email cria um segredo em nome do cliente. O segredo usa uma convenção de nomenclatura reservada e restringe as atualizações do cliente. Para ter mais informações, consulte [Como usar o SSRS Email para enviar relatórios](SSRS.Email.md). | 26 de agosto de 2022 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou um novo namespace do Amazon CloudWatch ao `AmazonRDSPreviewServiceRolePolicy` para `PutMetricData`. Esse namespace é necessário para que o Amazon RDS publique métricas de uso de recursos. Para ter mais informações, consulte [Usar chaves de condição para limitar o acesso a namespaces do CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) no *Guia do usuário do Amazon CloudWatch*. | 7 de junho de 2022 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou um novo namespace do Amazon CloudWatch ao `AmazonRDSBetaServiceRolePolicy` para `PutMetricData`. Esse namespace é necessário para que o Amazon RDS publique métricas de uso de recursos. Para ter mais informações, consulte [Usar chaves de condição para limitar o acesso a namespaces do CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) no *Guia do usuário do Amazon CloudWatch*. | 7 de junho de 2022 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou um novo namespace do Amazon CloudWatch ao `AWSServiceRoleForRDS` para `PutMetricData`. Esse namespace é necessário para que o Amazon RDS publique métricas de uso de recursos. Para ter mais informações, consulte [Usar chaves de condição para limitar o acesso a namespaces do CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) no *Guia do usuário do Amazon CloudWatch*. | 22 de abril de 2022 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novas permissões à função `AWSServiceRoleForRDS` vinculada a serviços para gerenciar permissões para grupos de IP de propriedade do cliente e tabelas de rotas de gateway local (LGW-RTBs). Essas permissões são necessárias para que o RDS on Outposts execute a replicação multi-AZ na rede local do Outposts. Para ter mais informações, consulte [Trabalhar com implantações multi-AZ para o Amazon RDS no AWS Outposts](rds-on-outposts.maz.md). | 19 de abril de 2022 |
| [Políticas baseadas em identidade](UsingWithRDS.IAM.md#security_iam_access-manage-id-based-policies): atualizar para uma política existente | O Amazon RDS adicionou uma nova permissão à política gerenciada `AmazonRDSFullAccess` para descrever permissões em LGW-RTBs. Essa permissão é necessária para que o RDS on Outposts execute a replicação multi-AZ na rede local do Outposts. Para ter mais informações, consulte [Trabalhar com implantações multi-AZ para o Amazon RDS no AWS Outposts](rds-on-outposts.maz.md). | 19 de abril de 2022 |
| [AWSPolíticas gerenciadas pela para o Amazon RDS](rds-security-iam-awsmanpol.md) – Nova política | O Amazon RDS adicionou uma nova política gerenciada denominada `AmazonRDSPerformanceInsightsReadOnly`, para permitir que o Amazon RDS chame serviços da AWS em nome de suas instâncias de banco de dados. Para receber mais informações sobre como configurar políticas de acesso para o Insights de Performance, consulte [Configurar políticas de acesso para o Performance Insights](USER_PerfInsights.access-control.md). | 10 de março de 2022 |
| [Permissões de função vinculada ao serviço do Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): atualizar para uma política existente | O Amazon RDS adicionou novos namespaces do Amazon CloudWatch ao `AWSServiceRoleForRDS` para `PutMetricData`. Esses namespaces são necessários para que o Amazon DocumentDB (compatível com MongoDB) e o Amazon Neptune publiquem métricas do CloudWatch. Para ter mais informações, consulte [Usar chaves de condição para limitar o acesso a namespaces do CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) no *Guia do usuário do Amazon CloudWatch*. | 4 de março de 2022 |
| [Permissões de funções vinculadas a serviços para o Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom) – Nova política | O Amazon RDS adicionou uma nova função vinculada ao serviço chamada `AWSServiceRoleForRDSCustom` para permitir que o RDS Custom chame Serviços da AWS em nome das instâncias de banco de dados. | 26 de outubro de 2021 |
| O Amazon RDS passou a monitorar alterações | O Amazon RDS passou a monitorar alterações nas políticas gerenciadas pela AWS. | 26 de outubro de 2021 |
# Prevenção do problema do substituto confuso entre serviços
O *problema “confused deputy”* é um problema de segurança em que uma entidade que não tem permissão para executar uma ação pode coagir uma entidade mais privilegiada a executá-la. Na AWS, a personificação entre serviços pode resultar no problema do ‘confused deputy’.
A personificação entre serviços pode ocorrer quando um serviço (o *serviço de chamada*) chama outro serviço (o *serviço chamado*). O serviço de chamada pode ser manipulado de modo a usar suas permissões para atuar nos recursos de outro cliente de uma forma na qual ele não deveria ter permissão para acessar. Para evitar isso, a AWS fornece ferramentas que ajudam você a proteger seus dados para todos os serviços com entidades principais de serviço que receberam acesso aos recursos em sua conta. Para obter mais informações, consulte [O problema confused deputy](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) no *Guia do usuário IAM*.
Recomendamos o uso das chaves de contexto de condição global [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) e [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) em políticas de recursos para limitar as permissões que o Amazon RDS concede a outro serviço para um recurso específico.
Em alguns casos, o valor `aws:SourceArn` não contém o ID da conta, por exemplo, quando você usa o nome do recurso da Amazon (ARN) para um bucket do Simple Storage Service (Amazon S3). Nesses casos, certifique-se de usar as duas chaves de contexto de condição global para limitar as permissões. Em alguns casos, você usa chaves de contexto de condição global e o valor `aws:SourceArn` contém o ID da conta. Nesses casos, verifique se o valor `aws:SourceAccount` e a conta no `aws:SourceArn` usa o mesmo ID de conta quando eles são usados na mesma instrução de política. Use se quiser que apenas um recurso seja associado ao acesso entre serviços `aws:SourceArn`. Use `aws:SourceAccount` se você quiser permitir que qualquer recurso nessa conta da AWS específica seja associado ao uso entre serviços.
Verifique se o valor de `aws:SourceArn` é um ARN para um tipo de recurso do Amazon RDS. Para obter mais informações, consulte [Nomes de recurso da Amazon (ARNs) no Amazon RDS](USER_Tagging.ARN.md).
A maneira mais eficaz de se proteger contra o problema do substituto confuso é usar a chave de contexto de condição global `aws:SourceArn` com o ARN completo do recurso. Em alguns casos, talvez você não saiba o ARN completo do recurso ou pode estar especificando vários recursos. Nesses casos, use a chave de condição de contexto global com curingas `aws:SourceArn` (`*`) para as partes desconhecidas do ARN. Um exemplo é `arn:aws:rds:*:123456789012:*`.
O exemplo a seguir mostra como é possível usar as chaves de contexto de condição global `aws:SourceArn` e `aws:SourceAccount` no Amazon RDS, a fim de evitar o problema do substituto confuso.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "ConfusedDeputyPreventionExamplePolicy",
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:rds:us-east-1:123456789012:db:mydbinstance"
},
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
}
```
------
Para obter mais exemplos de políticas que usam as chaves de contexto de condição global `aws:SourceArn` e `aws:SourceAccount`, consulte as seguintes seções:
+ [Conceder permissões para publicar notificações em um tópico do Amazon SNS](USER_Events.GrantingPermissions.md)
+ [Criar manualmente uma função do IAM para backup e restauração nativos](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ [Configuração da autenticação do Windows para instâncias de banco de dados do SQL Server](USER_SQLServerWinAuth.SettingUp.md)
+ [Pré-requisitos para integrar o RDS for SQL Server com o S3](Appendix.SQLServer.Options.S3-integration.preparing.md)
+ [Criar manualmente uma função do IAM para a Auditoria do SQL Server](Appendix.SQLServer.Options.Audit.IAM.md)
+ [Configurar permissões do IAM para a integração do RDS para Oracle com o Amazon S3](oracle-s3-integration.preparing.md)
+ [Configurar o acesso a um bucket do Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md) (Importação do PostgreSQL)
+ [Configurar o acesso a um bucket do Amazon S3](postgresql-s3-export-access-bucket.md) (Exportação do PostgreSQL)
# 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. |
# Solução de problemas de identidade e acesso do Amazon RDS
Use as seguintes informações para ajudar a diagnosticar e corrigir problemas comuns que podem ser encontrados ao trabalhar com o Amazon RDS e o IAM.
**Topics**
+ [Não estou autorizado a realizar uma ação no Amazon RDS](#security_iam_troubleshoot-no-permissions)
+ [Não estou autorizado a executar iam:PassRole](#security_iam_troubleshoot-passrole)
+ [Quero permitir que pessoas fora de minha conta da AWS acessem meus recursos do Amazon RDS](#security_iam_troubleshoot-cross-account-access)
## Não estou autorizado a realizar uma ação no Amazon RDS
Se o Console de gerenciamento da AWS informar que você não está autorizado a executar uma ação, será necessário entrar em contato com o administrador para obter assistência. Seu administrador é a pessoa que forneceu a você suas credenciais de início de sessão.
O exemplo de erro a seguir ocorre quando o usuário `mateojackson` tenta usar o console para visualizar detalhes sobre um *widget*, mas não tem as permissões `rds:GetWidget`.
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: rds:GetWidget on resource: my-example-widget
```
Neste caso, Mateo pede ao administrador para atualizar suas políticas para permitir a ele o acesso ao recurso `my-example-widget` usando a ação `rds:GetWidget`.
## Não estou autorizado a executar iam:PassRole
Se você receber uma mensagem de erro informando que você não está autorizado a executar a ação `iam:PassRole`, entre em contato com o administrador para obter assistência. Caso seu administrador seja a pessoa que forneceu suas credenciais de início de sessão. Peça a essa pessoa para atualizar suas políticas para permitir que você passe uma função para o Amazon RDS.
Alguns serviços da AWS permitem que você passe uma função existente para o serviço, em vez de criar um novo perfil de serviço ou perfil vinculado ao serviço. Para fazer isso, um usuário deve ter permissões para passar a função para o serviço.
O erro de exemplo a seguir ocorre quando uma usuária chamada `marymajor` tenta usar o console para executar uma ação no Amazon RDS. No entanto, a ação exige que o serviço tenha permissões concedidas por um perfil de serviço. Mary não tem permissões para passar a função para o serviço.
```
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
```
Neste caso, Mary pede ao administrador para atualizar suas políticas para permitir que ela execute a ação `iam:PassRole`.
## Quero permitir que pessoas fora de minha conta da AWS acessem meus recursos do Amazon RDS
É possível criar um perfil que os usuários de outras contas ou pessoas fora da organização podem usar para acessar seus recursos. É possível especificar quem é confiável para assumir o perfil. Para serviços que oferecem compatibilidade com políticas baseadas em recursos ou listas de controle de acesso (ACLs), é possível usar essas políticas para conceder às pessoas acesso aos seus recursos.
Para saber mais, consulte o seguinte:
+ Para saber se o Amazon RDS oferece suporte a esses recursos, consulte [Como o Amazon RDS funciona com o IAM](security_iam_service-with-iam.md).
+ Para saber como conceder acesso a seus recursos em todas as contas da AWS pertencentes a você, consulte [Fornecer acesso a um usuário do IAM em outra conta da AWS pertencente a você](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) no *Guia de usuário do IAM*.
+ Para saber como conceder acesso aos recursos para contas da AWS de terceiros, consulte [Fornecer acesso a contas da AWS pertencentes a terceiros](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html) no *Guia do usuário do IAM*.
+ Para saber como conceder acesso por meio da federação de identidades, consulte [Conceder acesso a usuários autenticados externamente (federação de identidades)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) no *Guia do usuário do IAM*.
+ Para saber a diferença entre usar perfis e políticas baseadas em recursos para acesso entre contas, consulte [Como os perfis do IAM diferem de políticas baseadas em recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html) no *Guia do usuário do IAM*.