# Administración de la identidad y el acceso en Amazon RDS
AWS Identity and Access Management (IAM) es un Servicio de AWS que ayuda a los gestionadores a controlar de forma segura el acceso a los recursos de AWS. Los administradores de IAM controlan quién se puede *autenticar* (iniciar sesión) y *autorizar* (tener permisos) para utilizar los recursos de Amazon RDS. IAM es un servicio de Servicio de AWS que se puedes utilizar sin cargo adicional.
**Topics**
+ [
## Público
](#security_iam_audience)
+ [
## Autenticación con identidades
](#security_iam_authentication)
+ [
## Administración de acceso mediante políticas
](#security_iam_access-manage)
+ [
# Cómo funciona Amazon RDS con IAM
](security_iam_service-with-iam.md)
+ [
# Ejemplos de políticas basadas en identidad para Amazon RDS
](security_iam_id-based-policy-examples.md)
+ [
# AWSPolíticas administradas por para Amazon RDS
](rds-security-iam-awsmanpol.md)
+ [
# Actualizaciones de Amazon RDS a políticas administradas por AWS
](rds-manpol-updates.md)
+ [
# Prevención de los problemas del suplente confuso entre servicios
](cross-service-confused-deputy-prevention.md)
+ [
# Autenticación de bases de datos de IAM para MariaDB, MySQL, and PostgreSQL
](UsingWithRDS.IAMDBAuth.md)
+ [
# Solución de problemas de identidades y accesos en Amazon RDS
](security_iam_troubleshoot.md)
## Público
La forma en que utiliza AWS Identity and Access Management (IAM) difiere en función del trabajo que realiza en Amazon RDS.
**Usuario de servicio**: si utiliza el servicio Amazon RDS para realizar su trabajo, su administrador le proporciona las credenciales y los permisos que necesita. A medida que utilice más características de Amazon RDS para realizar su trabajo, es posible que necesite permisos adicionales. Entender cómo se administra el acceso puede ayudarle a solicitar los permisos correctos a su administrador. Si no puede acceder a una característica en Amazon RDS, consulte [Solución de problemas de identidades y accesos en Amazon RDS](security_iam_troubleshoot.md).
**Administrador de servicio**: si está a cargo de los recursos de –Amazon RDS en su empresa, probablemente tenga acceso completo a Amazon RDS. Su trabajo consiste en determinar qué a características y recursos de Amazon RDS deben acceder sus empleados. A continuación, debe enviar solicitudes a su administrador de para cambiar los permisos de los usuarios de su servicio. Revise la información de esta página para conocer los conceptos básicos de IAM. Para obtener más información sobre cómo su empresa puede utilizar IAM con Amazon RDS, consulte [Cómo funciona Amazon RDS con IAM](security_iam_service-with-iam.md).
**Administrador**: si es un administrador de IAM, es posible que quiera conocer información sobre cómo escribir políticas para administrar el acceso a Amazon RDS. Para ver ejemplos de políticas basadas en la identidad de Amazon RDS que puede utilizar en IAM, consulte [Ejemplos de políticas basadas en identidad para Amazon RDS](security_iam_id-based-policy-examples.md).
## Autenticación con identidades
La autenticación es la manera de iniciar sesión en AWS mediante credenciales de identidad. Debe estar autenticado como Usuario raíz de la cuenta de AWS, un usuario de IAM o asumiendo un rol de IAM.
Puede iniciar sesión como una identidad federada con las credenciales de un origen de identidad, como AWS IAM Identity Center (IAM Identity Center), la autenticación de inicio de sesión único o las credenciales de Google/Facebook. Para obtener más información sobre el inicio de sesión, consulte [Cómo iniciar sesión en la Cuenta de AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) en la *Guía del usuario de AWS Sign-In*.
Para el acceso programático, AWS proporciona un SDK y una CLI para firmar criptográficamente las solicitudes. Para obtener más información, consulte [AWS Signature Version 4 para solicitudes de API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) en la *Guía del usuario de IAM*.
### Usuario raíz de la cuenta de AWS
Cuando se crea una Cuenta de AWS, se comienza con una identidad de inicio de sesión llamada Cuenta de AWS del *usuario raíz* que tiene acceso completo a todos los Servicios de AWS y recursos. Recomendamos encarecidamente que no utilice el usuario raíz para las tareas diarias. Para ver las tareas que requieren credenciales de usuario raíz, consulte [Tareas que requieren credenciales de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) en la *Guía del usuario de IAM*.
### Identidad federada
Como práctica recomendada, exija a los usuarios humanos que utilicen la federación con un proveedor de identidades para acceder a Servicios de AWS con credenciales temporales.
Una *identidad federada* es un usuario del directorio empresarial, proveedor de identidades web o Directory Service que accede a Servicios de AWS mediante credenciales de un origen de identidad. Las identidades federadas asumen roles que proporcionan credenciales temporales.
Para una administración de acceso centralizada, le recomendamos AWS IAM Identity Center. Para obtener más información, consulte [¿Qué es el Centro de identidades de IAM?](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html) en la *Guía del usuario de AWS IAM Identity Center*.
### Usuarios y grupos de IAM
Un *[usuario de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* es una identidad con permisos específicos para una sola persona o aplicación. Recomendamos el uso de credenciales temporales en lugar de usuarios de IAM con credenciales a largo plazo. Para obtener más información, consulte [Solicitar que los usuarios humanos utilicen la federación con un proveedor de identidades para acceder a AWS mediante credenciales temporales](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) en la *Guía del usuario de IAM*.
Un [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) especifica un conjunto de usuarios de IAM y facilita la administración de los permisos para grupos grandes de usuarios. Para obtener más información, consulte [Casos de uso para usuarios de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) en la *Guía del usuario de IAM*.
Puede autenticar en si instancia utilizando autenticación de base de datos de IAM.
La autenticación de base de datos de IAM funciona con los siguientes motores de base de datos:
+ RDS para MariaDB
+ RDS for MySQL
+ RDS para PostgreSQL
Para obtener más información sobre la autenticación en su instancia con IAM, consulte [Autenticación de bases de datos de IAM para MariaDB, MySQL, and PostgreSQL](UsingWithRDS.IAMDBAuth.md).
### Roles de IAM
Un *[rol de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* es una identidad de la Cuenta de AWS que dispone de permisos específicos. Es similar a un usuario, pero no está asociado a una persona específica. Puede asumir temporalmente un rol de IAM en la Consola de administración de AWS [cambiando de roles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html). Puede asumir un rol llamando a una operación de la AWS CLI o de la API de AWS, o utilizando una URL personalizada. Para más información sobre los métodos para el uso de roles, consulte [Uso de roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) en la *Guía del usuario de IAM*.
Los roles de IAM con credenciales temporales son útiles en las siguientes situaciones:
+ **Permisos de usuario temporales**: un usuario puede asumir un rol de IAM para recibir temporalmente permisos distintos que le permitan realizar una tarea concreta.
+ **Acceso de usuario federado**: para asignar permisos a una identidad federada, puede crear un rol y definir sus permisos. Cuando se autentica una identidad federada, se asocia la identidad al rol y se le conceden los permisos define el rol. Para obtener información acerca de roles de federación, consulte [Crear un rol para un proveedor de identidad de terceros (federación)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) en la *Guía de usuario de IAM*. Si utiliza el IAM Identity Center, debe configurar un conjunto de permisos. IAM Identity Center correlaciona el conjunto de permisos con un rol en IAM para controlar a qué pueden acceder las identidades después de autenticarse. Para obtener información acerca de los conjuntos de permisos, consulta [Conjuntos de permisos](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) en la *Guía del usuario de AWS IAM Identity Center*.
+ **Acceso entre cuentas**: puede utilizar un rol de IAM para permitir que alguien (una entidad principal de confianza) de otra cuenta acceda a los recursos de la cuenta. Los roles son la forma principal de conceder acceso entre cuentas. No obstante, con algunos Servicios de AWS se puede adjuntar una política directamente a un recurso (en lugar de utilizar un rol como representante). Para obtener información acerca de la diferencia entre los roles y las políticas basadas en recursos para el acceso entre cuentas, consulte [Cómo los roles de IAM difieren de las políticas basadas en recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html) en la *Guía del usuario de IAM*.
+ **Acceso entre servicios**: algunos Servicios de AWS utilizan características de otros Servicios de AWS. Por ejemplo, cuando realiza una llamada en un servicio, es común que ese servicio ejecute aplicaciones en Amazon EC2 o almacene objetos en Amazon S3. Es posible que un servicio haga esto usando los permisos de la entidad principal, usando un rol de servicio o usando un rol vinculado al servicio.
+ **Sesiones de acceso directo**: las sesiones de acceso directo (FAS) utilizan los permisos de la entidad principal para llamar a un Servicio de AWS, combinados con el Servicio de AWS solicitante para realizar solicitudes a servicios posteriores. Para obtener información sobre las políticas a la hora de realizar solicitudes de FAS, consulte [Reenviar sesiones de acceso](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html).
+ **Rol de servicio**: un rol de servicio es un [rol de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que adopta un servicio para realizar acciones en su nombre. Un administrador de IAM puede crear, modificar y eliminar un rol de servicio desde IAM. Para obtener más información, consulte [Creación de un rol para delegar permisos a un Servicio de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) en la *Guía del usuario de IAM*.
+ **Rol vinculado a los servicios**: un rol vinculado a servicios es un tipo de rol de servicio que está vinculado a un Servicio de AWS. El servicio puede asumir el rol para realizar una acción en su nombre. Los roles vinculados a servicios aparecen en la Cuenta de AWS y son propiedad del servicio. Un administrador de IAM puede ver, pero no editar, los permisos de los roles vinculados a servicios.
+ **Aplicaciones que se ejecutan en Amazon EC2**: puede utilizar un rol de IAM que le permita administrar credenciales temporales para las aplicaciones que se ejecutan en una instancia de EC2 y realizan solicitudes a la AWS CLI o a la API de AWS. Es preferible hacerlo de este modo a almacenar claves de acceso en la instancia de EC2. Para asignar un rol de AWS a una instancia de EC2 y ponerla a disposición de todas las aplicaciones, cree un perfil de instancia adjuntado a la instancia. Un perfil de instancia contiene el rol y permite a los programas que se ejecutan en la instancia de EC2 obtener credenciales temporales. Para obtener más información, consulte [Uso de un rol de IAM para conceder permisos a aplicaciones que se ejecutan en instancias Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html) en la *Guía del usuario de IAM*.
Para obtener información acerca del uso de los roles de IAM, consulte [Cuándo crear un rol de IAM (en vez de un usuario)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose_role) en la *Guía del usuario de IAM*.
## Administración de acceso mediante políticas
Para controlar el acceso en AWS, se crean políticas y se adjuntan a identidades de IAM o recursos de AWS. Una política es un objeto de AWS que, cuando se asocia a una identidad o un recurso, define sus permisos. AWS evalúa estas políticas cuando una entidad (usuario raíz, usuario o rol de IAM) realiza una solicitud. Los permisos en las políticas determinan si la solicitud se permite o se deniega. La mayoría de las políticas se almacenan en AWS como documentos JSON. Para obtener más información sobre la estructura y el contenido de los documentos de política JSON, consulte [Información general de políticas JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) en la *Guía del usuario de IAM*.
Un administrador puede utilizar las políticas para especificar quién tiene acceso a los recursos de AWS y qué acciones se pueden realizar en dichos recursos. Cada entidad de IAM (conjunto de permisos o rol) comienza sin permisos. En otras palabras, de forma predeterminada, los usuarios no pueden hacer nada, ni siquiera cambiar sus propias contraseñas. Para conceder permiso a un usuario para hacer algo, el administrador debe adjuntarle una política de permisos. O bien el administrador puede agregar al usuario a un grupo que tenga los permisos necesarios. Cuando el administrador concede permisos a un grupo, todos los usuarios de ese grupo obtienen los permisos.
Las políticas de IAM definen permisos para una acción independientemente del método que se utilice para realizar la operación. Por ejemplo, suponga que dispone de una política que permite la acción `iam:GetRole`. Un usuario con dicha política puede obtener información del usuario de la Consola de administración de AWS, la AWS CLI o la API de AWS.
### Políticas basadas en identidades
Las políticas basadas en identidad son documentos de políticas de permisos JSON que puede asociar a una identidad, como por ejemplo, un conjunto de permisos o un rol. Estas políticas controlan qué acciones puede realizar dicha identidad, en qué recursos y en qué condiciones. Para obtener más información sobre cómo crear una política basada en identidades, consulte [Creación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) en la *Guía del usuario de IAM*.
Las políticas basadas en identidades pueden clasificarse además como *políticas insertadas* o *políticas administradas*. Las políticas insertadas se integran directamente en un único conjunto de permisos o un rol. Las políticas administradas son políticas independientes que puede asociar a varios conjuntos de permisos o roles de su cuenta de AWS. Las políticas administradas incluyen las políticas administradas por AWS y las políticas administradas por el cliente. Para más información sobre cómo elegir una política administrada o una política insertada, consulte [Elegir entre políticas administradas y políticas insertadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#choosing-managed-or-inline) en la *Guía del usuario de IAM*.
Para obtener información sobre las políticas administradas de AWS que son específicas de Amazon RDS, consulte [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md).
### Otros tipos de políticas
AWS admite otros tipos de políticas adicionales menos frecuentes. Estos tipos de políticas pueden establecer el máximo de permisos que los tipos de políticas más frecuentes le conceden.
+ **Límites de permisos**: un límite de permisos es una característica avanzada que le permite establecer los permisos máximos que una política basada en identidad puede conceder a una entidad (conjunto de permisos o rol). Puede establecer un límite de permisos para una identidad. Los permisos resultantes son la intersección de las políticas basadas en identidad de la entidad y los límites de sus permisos. Las políticas basadas en recursos que especifiquen el conjunto de permisos o rol en el campo `Principal` no están restringidos por el límite de permisos. Una denegación explícita en cualquiera de estas políticas anulará el permiso. Para obtener más información sobre los límites de los permisos, consulte [Límites de permisos para las entidades de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) en la *Guía del usuario de IAM*.
+ **Políticas de control de servicio (SCP)**: las SCP son políticas de JSON que especifican los permisos máximos de una organización o una unidad organizativa (OU) en AWS Organizations. AWS Organizations es un servicio que le permite agrupar y administrar de manera centralizada varias cuentas de AWS que posea su empresa. Si habilita todas las características en una empresa, entonces podrá aplicar políticas de control de servicio (SCP) a una o todas sus cuentas. Una SCP limita los permisos para las entidades de las cuentas de miembros, incluido cada Usuario raíz de la cuenta de AWS. Para obtener más información acerca de Organizations y las SCP, consulte [Funcionamiento de las SCP](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html) en la *Guía del usuario de AWS Organizations*.
+ **Políticas de sesión**: las políticas de sesión son políticas avanzadas que se pasan como parámetro cuando se crea una sesión temporal mediante programación para un rol o un usuario federado. Los permisos de la sesión resultantes son la intersección de las políticas basadas en identidad del conjunto de permisos o rol y las políticas de la sesión. Los permisos también pueden proceder de una política en función de recursos. Una denegación explícita en cualquiera de estas políticas anulará el permiso. Para más información, consulte [Políticas de sesión](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session) en la *Guía del usuario de IAM*.
### Varios tipos de políticas
Cuando se aplican varios tipos de políticas a una solicitud, los permisos resultantes son más complicados de entender. Para obtener información acerca de cómo AWS decide si permitir o no una solicitud cuando hay varios tipos de políticas implicados, consulte [Lógica de evaluación de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html) en la *Guía del usuario de IAM*.
# Cómo funciona Amazon RDS con IAM
Antes de utilizar IAM para administrar el acceso a Amazon RDS, debe saber qué características de IAM están disponibles para usar con Amazon RDS.
En la siguiente tabla, encontrará las características de IAM que puede usar con Amazon RDS:
| Característica de IAM | Compatibilidad de Amazon RDS |
| --- | --- |
| [Políticas basadas en identidades](#security_iam_service-with-iam-id-based-policies) | Sí |
| [Políticas basadas en recursos](#security_iam_service-with-iam-resource-based-policies) | No |
| [Acciones de políticas](#security_iam_service-with-iam-id-based-policies-actions) | Sí |
| [Recursos de políticas](#security_iam_service-with-iam-id-based-policies-resources) | Sí |
| [Claves de condición de política (específicas del servicio)](#UsingWithRDS.IAM.Conditions) | Sí |
| [ACL](#security_iam_service-with-iam-acls) | No |
| [Control de acceso basado en atributos (ABAC) (etiquetas en políticas)](#security_iam_service-with-iam-tags) | Sí |
| [Credenciales temporales](#security_iam_service-with-iam-roles-tempcreds) | Sí |
| [Sesiones de acceso directo](#security_iam_service-with-iam-principal-permissions) | Sí |
| [Roles de servicio](#security_iam_service-with-iam-roles-service) | Sí |
| [Roles vinculados al servicio](#security_iam_service-with-iam-roles-service-linked) | Sí |
Para obtener una perspectiva general de cómo funciona Amazon RDS y otros servicios de AWS con IAM, consulte los [servicios de AWS que funcionan con IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) en la *guía del usuario de IAM*.
**Topics**
+ [
## Políticas de Amazon RDS basadas en identidades
](#security_iam_service-with-iam-id-based-policies)
+ [
## Políticas basadas en recursos de Amazon RDS
](#security_iam_service-with-iam-resource-based-policies)
+ [
## Acciones de política de Amazon RDS
](#security_iam_service-with-iam-id-based-policies-actions)
+ [
## Recursos de políticas de Amazon RDS
](#security_iam_service-with-iam-id-based-policies-resources)
+ [
## Claves de condición de políticas para Amazon RDS
](#UsingWithRDS.IAM.Conditions)
+ [
## Listas de control de acceso (ACL) de Amazon RDS
](#security_iam_service-with-iam-acls)
+ [
## Control de acceso basado en atributos (ABAC) en políticas con etiquetas de Amazon RDS
](#security_iam_service-with-iam-tags)
+ [
## Uso de credenciales temporales con Amazon RDS
](#security_iam_service-with-iam-roles-tempcreds)
+ [
## Sesiones de acceso directo para Amazon RDS
](#security_iam_service-with-iam-principal-permissions)
+ [
## Roles de servicio para Amazon RDS
](#security_iam_service-with-iam-roles-service)
+ [
## Roles vinculados a servicios para Amazon RDS
](#security_iam_service-with-iam-roles-service-linked)
## Políticas de Amazon RDS basadas en identidades
**Admite las políticas basadas en identidad:** sí.
Las políticas basadas en identidad son documentos de políticas de permisos JSON que puede asociar a una identidad, como un usuario de IAM, un grupo de usuarios o un rol. Estas políticas controlan qué acciones pueden realizar los usuarios y los roles, en qué recursos y en qué condiciones. Para obtener más información sobre cómo crear una política basada en la identidad, consulte [Definición de permisos de IAM personalizados con políticas administradas por el cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) en la *Guía del usuario de IAM*.
Con las políticas basadas en identidades de IAM, puede especificar las acciones y los recursos permitidos o denegados, así como las condiciones en las que se permiten o deniegan las acciones. Para obtener más información sobre los elementos que puede utilizar en una política de JSON, consulte [Referencia de los elementos de la política de JSON de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) en la *Guía del usuario de IAM*.
### Ejemplos de políticas de Amazon RDS basadas en identidades
Para ver ejemplos de políticas basadas en identidad de Amazon RDS, consulte [Ejemplos de políticas basadas en identidad para Amazon RDS](security_iam_id-based-policy-examples.md).
## Políticas basadas en recursos de Amazon RDS
**Admite políticas basadas en recursos:** no.
Las políticas basadas en recursos son documentos de política JSON que se asocian a un recurso. Los ejemplos de políticas basadas en recursos son las *políticas de confianza de roles* de IAM y las *políticas de bucket* de Amazon S3. En los servicios que admiten políticas basadas en recursos, los administradores de servicios pueden utilizarlos para controlar el acceso a un recurso específico. Para el recurso al que se asocia la política, la política define qué acciones puede realizar una entidad principal especificada en ese recurso y en qué condiciones. Debe [especificar una entidad principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) en una política basada en recursos. Las entidades principales pueden incluir cuentas, usuarios, roles, usuarios federados o Servicios de AWS.
Para habilitar el acceso entre cuentas, puede especificar toda una cuenta o entidades de IAM de otra cuenta como la entidad principal de una política en función de recursos. Para obtener más información, consulte [Acceso a recursos entre cuentas en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) en la *Guía del usuario de IAM*.
## Acciones de política de Amazon RDS
**Admite las acciones de política:** sí.
Los administradores pueden utilizar las políticas JSON de AWS para especificar quién tiene acceso a qué. Es decir, qué **entidad principal** puede realizar **acciones** en qué **recursos** y en qué **condiciones**.
El elemento `Action` de una política JSON describe las acciones que puede utilizar para conceder o denegar el acceso en una política. Incluya acciones en una política para conceder permisos y así llevar a cabo la operación asociada.
Las acciones de políticas de Amazon RDS utilizan el siguiente prefijo antes de la acción: `rds:`. Por ejemplo, para conceder a alguien permiso para eliminar un punto de enlace de Amazon RDS con la operación de la API `DescribeDBInstances` de `rds:DescribeDBInstances`, incluya la acción en su política. Las instrucciones de la política deben incluir un elemento `Action` o un elemento `NotAction`. Amazon RDS define su propio conjunto de acciones que describen las tareas que se pueden realizar con este servicio.
Para especificar varias acciones de en una única instrucción, sepárelas con comas del siguiente modo.
```
"Action": [
"rds:action1",
"rds:action2"
```
Puede utilizar caracteres comodín (\$1) para especificar varias acciones . Por ejemplo, para especificar todas las acciones que comiencen con la palabra `Describe`, incluya la siguiente acción.
```
"Action": "rds:Describe*"
```
Para ver una lista de las acciones de Amazon RDS, consulte [Acciones definidas por Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions) en la *referencia de autorizaciones de servicio*.
## Recursos de políticas de Amazon RDS
**Admite los recursos de políticas:** sí.
Los administradores pueden utilizar las políticas JSON de AWS para especificar quién tiene acceso a qué. Es decir, qué **entidad principal** puede realizar **acciones** en qué **recursos** y en qué **condiciones**.
El elemento `Resource` de la política JSON especifica el objeto u objetos a los que se aplica la acción. Como práctica recomendada, especifique un recurso utilizando el [Nombre de recurso de Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). En el caso de las acciones que no admiten permisos por recurso, utilice un carácter comodín (\$1) para indicar que la instrucción se aplica a todos los recursos.
```
"Resource": "*"
```
El recurso de instancia de base de datos tiene el siguiente nombre de recurso de Amazon (ARN).
```
arn:${Partition}:rds:${Region}:${Account}:{ResourceType}/${Resource}
```
Para obtener más información acerca del formato de los ARN, consulte [Nombres de recursos de Amazon (ARN) y espacios de nombres de servicios de AWS](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
Por ejemplo, para especificar la instancia de base de datos `dbtest` en su instrucción, utilice el siguiente ARN.
```
"Resource": "arn:aws:rds:us-west-2:123456789012:db:dbtest"
```
Para especificar todas las instancias de base de datos que pertenecen a una cuenta específica, utilice el carácter comodín (\$1).
```
"Resource": "arn:aws:rds:us-east-1:123456789012:db:*"
```
Algunas operaciones de API de RDS, como las empleadas para la creación de recursos, no se pueden llevar a cabo en un recurso específico. En dichos casos, utilice el carácter comodín (\$1).
```
"Resource": "*"
```
En muchas operaciones de la API de Amazon RDS se utilizan varios recursos. Por ejemplo, `CreateDBInstance` crea una instancia de base de datos. Puede especificar que un usuario de debe usar un grupo de seguridad y un grupo de parámetros específicos al crear una instancia de base de datos. Para especificar varios recursos en una única instrucción, separe los ARN con comas.
```
"Resource": [
"resource1",
"resource2"
```
Para ver una lista de las acciones de Amazon RDS, consulte [Recursos definidos por Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-resources-for-iam-policies) en la *referencia de autorizaciones de servicio*. Para obtener información sobre las acciones con las que puede especificar el ARN de cada recurso, consulte [Acciones definidas por Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions).
## Claves de condición de políticas para Amazon RDS
**Admite claves de condición de políticas específicas del servicio:** sí.
Los administradores pueden utilizar las políticas JSON de AWS para especificar quién tiene acceso a qué. Es decir, qué **entidad principal** puede realizar **acciones** en qué **recursos** y en qué **condiciones**.
El elemento `Condition` especifica cuándo se ejecutan las instrucciones en función de criterios definidos. Puede crear expresiones condicionales que utilizan [operadores de condición](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), tales como igual o menor que, para que la condición de la política coincida con los valores de la solicitud. Para ver todas las claves de condición globales de AWS, consulte [Claves de contexto de condición globales de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) en la *Guía del usuario de IAM*.
Amazon RDS define su propio conjunto de claves de condición y también admite el uso de algunas claves de condición globales. Para ver todas las claves de condición globales de AWS, consulte [Claves de contexto de condición globales de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) en la *Guía del usuario de IAM*.
Todas las operaciones de API de RDS admiten la clave de condición `aws:RequestedRegion`.
Para ver una lista de las claves de condición de Amazon RDS, consulte [Claves de condición de Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-policy-keys) en la *referencia de autorizaciones de servicio*. Para obtener más información acerca de las acciones y los recursos con los que puede utilizar una clave de condición, consulte [Acciones definidas por Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions).
## Listas de control de acceso (ACL) de Amazon RDS
**Admite las listas de control de acceso (ACL):** no
Las listas de control de acceso (ACL) controlan qué entidades principales (miembros de cuentas, usuarios o roles) tienen permisos para acceder a un recurso. Las ACL son similares a las políticas basadas en recursos, aunque no utilizan el formato de documento de políticas JSON.
## Control de acceso basado en atributos (ABAC) en políticas con etiquetas de Amazon RDS
**Admite las etiquetas de control de acceso basado en atributos (ABAC) en las políticas:** sí
El control de acceso basado en atributos (ABAC) es una estrategia de autorización que define permisos en función de atributos denominados etiquetas. Puede asociar etiquetas a entidades de IAM y recursos de AWS y, a continuación, diseñar políticas de ABAC para permitir operaciones cuando la etiqueta de la entidad principal coincida con la etiqueta del recurso.
Para controlar el acceso en función de etiquetas, debe proporcionar información de las etiquetas en el [elemento de condición](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de una política utilizando las claves de condición `aws:ResourceTag/key-name`, `aws:RequestTag/key-name` o `aws:TagKeys`.
Si un servicio admite las tres claves de condición para cada tipo de recurso, el valor es **Sí** para el servicio. Si un servicio admite las tres claves de condición solo para algunos tipos de recursos, el valor es **Parcial**.
*Para obtener más información sobre ABAC, consulte [Definición de permisos con la autorización de ABAC](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) en la Guía del usuario de IAM*. Para ver un tutorial con los pasos para configurar ABAC, consulte [Uso del control de acceso basado en atributos (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html) en la *Guía del usuario de IAM*.
Para obtener más información acerca del etiquetado de recursos de Amazon RDS, consulte [Especificación de condiciones: uso de etiquetas personalizadas](UsingWithRDS.IAM.SpecifyingCustomTags.md). Para consultar un ejemplo de política basada en la identidad para limitar el acceso a un recurso en función de las etiquetas de ese recurso, consulte [Conceda permiso para acciones en un recurso con una etiqueta específica con dos valores diferentes.](security_iam_id-based-policy-examples-create-and-modify-examples.md#security_iam_id-based-policy-examples-grant-permissions-tags).
## Uso de credenciales temporales con Amazon RDS
**Admite credenciales temporales:** sí.
Las credenciales temporales proporcionan acceso a corto plazo a los recursos de AWS y se crean automáticamente cuando se utiliza la federación o se cambia de rol. AWS recomienda generar credenciales temporales de forma dinámica en lugar de usar claves de acceso a largo plazo. Para obtener más información, consulte [Credenciales de seguridad temporales en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) y [Servicios de AWS que funcionan con IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) en la *Guía del usuario de IAM*.
## Sesiones de acceso directo para Amazon RDS
**Admite sesiones de acceso directo:** sí.
Las sesiones de acceso directo (FAS) utilizan los permisos de la entidad principal para llamar a un Servicio de AWS, combinados con el Servicio de AWS solicitante, para realizar solicitudes a servicios posteriores. Para obtener información sobre las políticas a la hora de realizar solicitudes de FAS, consulte [Sesiones de acceso directo](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html).
## Roles de servicio para Amazon RDS
**Admite roles de servicio:** sí.
Un rol de servicio es un [rol de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que asume un servicio para realizar acciones en su nombre. Un administrador de IAM puede crear, modificar y eliminar un rol de servicio desde IAM. Para obtener más información, consulte [Crear un rol para delegar permisos a un Servicio de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) en la *Guía del usuario de IAM*.
**aviso**
Cambiar los permisos de un rol de servicio podría interrumpir la funcionalidad de Amazon RDS. Edite los roles de servicio solo cuando Amazon RDS proporcione orientación para hacerlo.
## Roles vinculados a servicios para Amazon RDS
**Admite roles vinculados al servicio:** sí.
Un rol vinculado a servicios es un tipo de rol de servicio que está vinculado a un Servicio de AWS. El servicio puede asumir el rol para realizar una acción en su nombre. Los roles vinculados a servicios aparecen en la Cuenta de AWS y son propiedad del servicio. Un administrador de IAM puede ver, pero no editar, los permisos de los roles vinculados a servicios.
Para obtener más información acerca de cómo usar los roles vinculados a servicios de Amazon RDS, consulte [Uso de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md).
# Ejemplos de políticas basadas en identidad para Amazon RDS
De forma predeterminada, los conjuntos de permisos y roles no tienen permiso para crear ni modificar recursos de Amazon RDS. Tampoco pueden realizar tareas mediante la Consola de administración de AWS, la AWS CLI o la API de AWS. Un administrador debe crear políticas de IAM que concedan conjuntos de permisos y permisos de roles para realizar operaciones de API concretas en los recursos especificados necesarios. El administrador debe asociar esas políticas a los conjuntos de permisos o roles que necesiten esos permisos.
Para obtener más información acerca de cómo crear una política basada en identidad de IAM con estos documentos de políticas de JSON de ejemplo, consulte [Creación de políticas en la pestaña JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) en la *Guía del usuario de IAM*.
**Topics**
+ [
## Prácticas recomendadas relativas a políticas
](#security_iam_service-with-iam-policy-best-practices)
+ [
## Mediante la consola de Amazon RDS
](#security_iam_id-based-policy-examples-console)
+ [
## Permisos necesarios para usar la consola
](#UsingWithRDS.IAM.RequiredPermissions.Console)
+ [
## Cómo permitir a los usuarios consultar sus propios permisos
](#security_iam_id-based-policy-examples-view-own-permissions)
+ [
# Políticas de permisos para crear, modificar y eliminar recursos en Amazon RDS
](security_iam_id-based-policy-examples-create-and-modify-examples.md)
+ [
# Políticas de ejemplo: uso de claves de condición
](UsingWithRDS.IAM.Conditions.Examples.md)
+ [
# Especificación de condiciones: uso de etiquetas personalizadas
](UsingWithRDS.IAM.SpecifyingCustomTags.md)
+ [
# Concesión de permisos para etiquetar recursos de Amazon RDS durante la creación
](security_iam_id-based-policy-examples-grant-permissions-tags-on-create.md)
## Prácticas recomendadas relativas a políticas
Las políticas basadas en identidades determinan si alguien puede crear, eliminar o acceder a los recursos de Amazon RDS de su cuenta. Estas acciones pueden generar costos adicionales para su Cuenta de AWS. Siga estas directrices y recomendaciones al crear o editar políticas basadas en identidades:
+ **Comience a utilizar las políticas administradas de AWS y avance hacia permisos de privilegios mínimos**. Para empezar a conceder permisos a los usuarios y cargas de trabajo, utilice las *políticas administradas de AWS* que otorgan permisos para muchos casos de uso comunes. Están disponibles en su Cuenta de AWS. Se recomienda definir políticas administradas por el cliente de AWS específicas para sus casos de uso a fin de reducir aún más los permisos. Con el fin de obtener más información, consulte las [políticas administradas por AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) o las [políticas administradas por AWS para funciones de tarea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) en la *Guía de usuario de IAM*.
+ **Aplique permisos de privilegio mínimo**: cuando establezca permisos con políticas de IAM, conceda solo los permisos necesarios para realizar una tarea. Para ello, debe definir las acciones que se pueden llevar a cabo en determinados recursos en condiciones específicas, también conocidos como *permisos de privilegios mínimos*. Con el fin de obtener más información sobre el uso de IAM para aplicar permisos, consulte [Políticas y permisos en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) en la *Guía del usuario de IAM*.
+ **Utilice condiciones en las políticas de IAM para restringir aún más el acceso**: puede agregar una condición a sus políticas para limitar el acceso a las acciones y los recursos. Por ejemplo, puede escribir una condición de políticas para especificar que todas las solicitudes deben enviarse utilizando SSL. También puede usar condiciones para conceder acceso a acciones de servicios si se emplean a través de un Servicio de AWS determinado como, por ejemplo, CloudFormation. Para obtener más información, consulte [Elementos de la política de JSON de IAM: Condición](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) en la *Guía del usuario de IAM*.
+ **Utiliza el analizador de acceso de IAM para validar las políticas de IAM con el fin de garantizar la seguridad y funcionalidad de los permisos**: el analizador de acceso de IAM valida políticas nuevas y existentes para que respeten el lenguaje (JSON) de las políticas de IAM y las prácticas recomendadas de IAM. El analizador de acceso de IAM proporciona más de 100 verificaciones de políticas y recomendaciones procesables para ayudar a crear políticas seguras y funcionales. Para más información, consulte [Validación de políticas con el Analizador de acceso de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) en la *Guía del usuario de IAM*.
+ **Solicite la autenticación multifactor (MFA)**: si se encuentra en una situación en la que necesite usuarios raíz o de IAM en su Cuenta de AWS, active la MFA para obtener una mayor seguridad. Para exigir la MFA cuando se invoquen las operaciones de la API, añada condiciones de MFA a sus políticas. Para más información, consulte [Acceso seguro a la API con MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) en la *Guía del usuario de IAM*.
Para obtener más información sobre las prácticas recomendadas de IAM, consulte [Prácticas recomendadas de seguridad en IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) en la *Guía del usuario de IAM*.
## Mediante la consola de Amazon RDS
Para acceder a la consola de Amazon RDS, debe tener un conjunto mínimo de permisos. Estos permisos deben permitirle enumerar y consultar los detalles sobre los recursos de Amazon RDS en su cuenta de Cuenta de AWS. Si crea una política basada en identidades que sea más restrictiva que el mínimo de permisos necesarios, la consola no funcionará del modo esperado para las entidades (usuarios o roles) que tengan esa política.
No es necesario conceder permisos mínimos para la consola a los usuarios que solo realizan llamadas a la AWS CLI o a la API de AWS. En su lugar, permite acceso únicamente a las acciones que coincidan con la operación de API que intenta realizar.
Para asegurarse de que esas entidades puedan seguir usando la consola de Amazon RDS, asocie también la siguiente política administrada por AWS a las entidades.
```
AmazonRDSReadOnlyAccess
```
Para obtener más información, consulte [Adición de permisos a un usuario](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) en la *Guía del usuario de IAM*:
## Permisos necesarios para usar la consola
Para que un usuario pueda trabajar con la consola, debe tener un conjunto mínimo de permisos. Estos permisos permiten al usuario describir los recursos de Amazon RDS de su cuenta de AWS y proporcionar otra información relacionada, incluida información de red y seguridad de Amazon EC2.
Si crea una política de IAM que sea más restrictiva que el mínimo de permisos necesarios, la consola no funciona del modo esperado para los usuarios con esa política de IAM. Para asegurarse de que esos usuarios puedan seguir usando la consola, asocie también la política administrada `AmazonRDSReadOnlyAccess` al usuario, según se explica en [Administración de acceso mediante políticas](UsingWithRDS.IAM.md#security_iam_access-manage).
No es necesario que conceda permisos mínimos para la consola a los usuarios que solo realizan llamadas a la AWS CLI o a la API de Amazon RDS.
La siguiente política concede acceso completo a todos los recursos de Amazon RDS para la cuenta de AWS raíz:
```
AmazonRDSFullAccess
```
## Cómo permitir a los usuarios consultar sus propios permisos
En este ejemplo, se muestra cómo podría crear una política que permita a los usuarios de IAM ver las políticas administradas e insertadas que se asocian a la identidad de sus usuarios. Esta política incluye permisos para llevar a cabo esta acción en la consola o mediante programación con la AWS CLI o la API de 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 permisos para crear, modificar y eliminar recursos en Amazon RDS
En las siguientes secciones, encontrará ejemplos de políticas de permisos para otorgar y limitar el acceso a los recursos:
## Permitir a un usuario crear en instancias de base de datos en una cuenta de AWS
A continuación, se muestra el ejemplo de una política que permite que la cuenta con el ID `123456789012` pueda crear instancias de base de datos para su cuenta AWS. La política requiere que el nombre de la nueva instancia de base de datos comience por `test`. La nueva instancia de base de datos también debe utilizar el motor de base de datos MySQL y la clase de instancia de base de datos `db.t2.micro`. Además, la nueva instancia de base de datos debe usar un grupo de opciones y un grupo de parámetros de base de datos que comience por `default` y debe utilizar el grupo de subred `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"
}
}
}
]
}
```
------
En la política se incluye una sola instrucción que especifica los siguientes permisos para el usuario de:
+ La política permite a la cuenta crear una instancia de base de datos utilizando la operación [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) de la API (esto también se aplica al comando [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) de la AWS CLI y a la Consola de administración de AWS).
+ El elemento `Resource` especifica que el usuario puede realizar acciones en o con recursos. Puede especificar los recursos mediante un nombre de recurso de Amazon (ARN). Este ARN incluye el nombre del servicio al que pertenece el recurso (`rds`), la región AWS (`*` indica cualquier región de este ejemplo), el número de cuenta de AWS (`123456789012` es el número de cuenta en este ejemplo) y el tipo de recurso. Para obtener más información acerca de la creación de nombres ARN, consulte [Nombres de recursos de Amazon (ARN) en Amazon RDS](USER_Tagging.ARN.md).
El elemento `Resource` del ejemplo especifica las siguientes restricciones políticas en los recursos del usuario:
+ El identificador de instancias de bases de datos para la nueva instancia de base de datos debe comenzar por `test` (por ejemplo, `testCustomerData1`, `test-region2-data`).
+ El grupo de opciones de la nueva instancia de base de datos debe empezar por `default`.
+ El grupo de parámetros de base de datos de la nueva instancia de base de datos debe empezar por `default`.
+ El grupo de subred de la nueva instancia de base de datos debe ser el grupo de subred `default`.
+ El elemento `Condition` especifica que el motor de base de datos debe ser MySQL, mientras que la clase de instancia de base de datos debe ser `db.t2.micro`. El elemento `Condition` especifica las condiciones en las que se debe aplicar una política. Puede añadir permisos o restricciones adicionales mediante el elemento `Condition`. Para obtener más información acerca de cómo especificar condiciones, consulte [Claves de condición de políticas para Amazon RDS](security_iam_service-with-iam.md#UsingWithRDS.IAM.Conditions). Este ejemplo especifica el estado del `rds:DatabaseEngine` y la `rds:DatabaseClass`. Para obtener más información acerca de los valores de estado válidos para `rds:DatabaseEngine`, consulte la lista bajo el parámetro `Engine` en [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Para obtener información acerca de los valores de estado válidos para `rds:DatabaseClass`, consulte [Motores de base de datos compatibles para clases de instancia de base de datos](Concepts.DBInstanceClass.Support.md).
La política no especifica el elemento `Principal`, ya que en una política basada en la identidad no se especifica el elemento principal que obtiene el permiso. Al asociar una política a un usuario, el usuario es la entidad principal implícita. Cuando se asocia una política de permisos a un rol de IAM, la entidad principal identificada en la política de confianza del rol obtiene los permisos.
Para ver una lista de las acciones de Amazon RDS, consulte [Acciones definidas por Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions) en la *referencia de autorizaciones de servicio*.
## Permitir que un usuario realice cualquier acción Describe con cualquier recurso de RDS
La siguiente política de permisos concede permisos a un usuario para ejecutar todas las acciones que empiezan por `Describe`. Estas acciones muestran información acerca de un recurso de RDS, como una instancia de base de datos. El carácter de comodín (\$1) en el elemento `Resource` indica que las acciones están permitidas para todos los recursos de Amazon RDS que pertenecen a la cuenta.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRDSDescribe",
"Effect": "Allow",
"Action": "rds:Describe*",
"Resource": "*"
}
]
}
```
------
## Permitirle al usuario crear una instancia de base de datos que use los grupos de parámetros de base de datos y de subredes especificados
La política de permisos siguiente otorga permisos para permitir que el usuario solo pueda crear una instancia de base de datos que use el grupo de parámetros de base de datos `mydbpg` y el grupo de subredes de base de datos `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"
]
}
]
}
```
------
## Conceda permiso para acciones en un recurso con una etiqueta específica con dos valores diferentes.
Puede utilizar las condiciones de su política basada en la identidad para controlar el acceso a los recursos de Amazon RDS basados en etiquetas. La siguiente política da permiso para aplicar la operación de API `CreateDBSnapshot` y `stage` en instancias de base de datos con la etiqueta `stage` establecida en `development` o `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"
]
}
}
}
]
}
```
------
La siguiente política da permiso para aplicar la operación de API `ModifyDBInstance` en instancias de base de datos con la etiqueta `stage` establecida en `development` o `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"
]
}
}
}
]
}
```
------
## Evitar que un usuario elimine una instancia de base de datos
La siguiente política de permisos concede permisos para impedir que un usuario elimine una instancia de base de datos específica. Por ejemplo, puede servir para impedir la eliminación de instancias de base de datos de producción a cualquier usuario que no sea un 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"
}
]
}
```
------
## Denegar todo el acceso a un recurso
Puede denegar explícitamente el acceso a un recurso. Las políticas de denegación tienen prioridad sobre las políticas de permiso. La política siguiente niega explícitamente a un usuario la capacidad de administrar un recurso:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "rds:*",
"Resource": "arn:aws:rds:us-east-1:123456789012:db:mydb"
}
]
}
```
------
# Políticas de ejemplo: uso de claves de condición
Los siguientes ejemplos muestran cómo puede usar claves de condición en las políticas de permisos de IAM para Amazon RDS.
## Ejemplo 1: conceder permiso para crear una instancia de base de datos que utilice un motor de base de datos específico y no sea Multi-AZ.
La siguiente política utiliza una clave de condición de RDS y permite al usuario crear solamente instancias de base de datos que utilizan el motor de base de datos MySQL y no utilizan Multi-AZ. El elemento `Condition` indica el requisito de que el motor de base de datos sea MySQL.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowMySQLCreate",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": "mysql"
},
"Bool": {
"rds:MultiAz": false
}
}
}
]
}
```
------
## Ejemplo 2: denegar permiso explícitamente para crear instancias de base de datos para determinadas clases de instancia de base de datos y crear instancias de base de datos que utilizan IOPS provisionadas
La siguiente política deniega permiso explícitamente para crear instancias de base de datos que utilizan las clases de instancia de base de datos `r3.8xlarge` y `m4.10xlarge`, que son las clases de instancia de base de datos más costosas y de mayor tamaño. Esta política también evita que los usuarios creen instancias de base de datos que utilizan IOPS provisionadas, las cuales tienen un costo adicional.
Al denegarse permiso explícitamente se sustituye a cualquier otro permiso concedido. Esto garantiza que las identidades no obtengan accidentalmente permisos que el usuario no desee conceder nunca.
------
#### [ 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"
}
}
}
]
}
```
------
## Ejemplo 3: limitar el conjunto de claves y valores de etiquetas que se pueden usar para etiquetar un recurso
En la siguiente política se usa una clave condicional de RDS y permite añadir una etiqueta con la clave `stage` a un recurso con los valores `test`, `qa` y `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"
]
}
}
}
]
}
```
------
# Especificación de condiciones: uso de etiquetas personalizadas
Amazon RDS admite la especificación de condiciones en una política de IAM que utiliza etiquetas personalizadas.
Por ejemplo, suponga que añade una etiqueta con el nombre `environment` a sus instancias de base de datos con valores como `beta`, `staging`, `production`, etc. Si lo hace, puede crear una política que restrinja a ciertos usuarios en instancias de bases de datos basándose en el valor de la etiqueta `environment`.
**nota**
Los identificadores de etiquetas personalizados distinguen entre mayúsculas y minúsculas.
En la tabla siguiente, se enumeran los identificadores de etiqueta de RDS que puede usar en un elemento `Condition`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/UsingWithRDS.IAM.SpecifyingCustomTags.html)
La sintaxis de una condición de etiqueta personalizada es la siguiente:
`"Condition":{"StringEquals":{"rds:rds-tag-identifier/tag-name": ["value"]} }`
Por ejemplo, el elemento `Condition` siguiente se aplica a instancias de base de datos con una etiqueta llamada `environment` y un valor de etiqueta `production`.
` "Condition":{"StringEquals":{"rds:db-tag/environment": ["production"]} } `
Para obtener información acerca de la creación etiquetas, consulte [Etiquetado de los recursos de Amazon RDS](USER_Tagging.md).
**importante**
Si administra el acceso a sus recursos de RDS mediante el etiquetado, recomendamos que proteja el acceso a las etiquetas. Puede administrar el acceso a etiquetas creando políticas para las acciones `AddTagsToResource` y `RemoveTagsFromResource`. Por ejemplo, la política siguiente deniega a los usuarios la posibilidad de agregar o quitar etiquetas para todos los recursos. A continuación, puede crear políticas para permitir que usuarios específicos agreguen o quiten etiquetas.
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"DenyTagUpdates",
"Effect":"Deny",
"Action":[
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource":"*"
}
]
}
```
Para ver una lista de las acciones de Amazon RDS, consulte [Acciones definidas por Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions) en la *referencia de autorizaciones de servicio*.
## Políticas de ejemplo: uso de etiquetas personalizadas
Los siguientes ejemplos muestran cómo puede usar etiquetas personalizadas en las políticas de permisos de IAM para Amazon RDS. Para obtener más información sobre cómo agregar etiquetas a un recurso de Amazon RDS, consulte [Nombres de recursos de Amazon (ARN) en Amazon RDS](USER_Tagging.ARN.md).
**nota**
Todos los ejemplos utilizan la región us-west-2 y contienen identificadores de cuenta ficticios.
### Ejemplo 1: conceda permiso para acciones en un recurso con una etiqueta específica con dos valores diferentes.
La siguiente política da permiso para aplicar la operación de API `CreateDBSnapshot` en instancias de base de datos con la etiqueta `stage` establecida en `development` o `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"
]
}
}
}
]
}
```
------
La siguiente política da permiso para aplicar la operación de API `ModifyDBInstance` en instancias de base de datos con la etiqueta `stage` establecida en `development` o `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"
]
}
}
}
]
}
```
------
### Ejemplo 2: deniegue explícitamente permiso para crear una instancia de base de datos que utilice grupos de parámetros de base de datos especificados.
La siguiente política deniega explícitamente permiso para crear una instancia de base de datos que utilice grupos de parámetros de base de datos con valores de etiqueta específicos. Podría aplicar esta política si necesita que se utilice siempre un grupo de parámetros de base de datos específico, creado por el cliente, al crear instancias de base de datos. Las políticas que utilizan `Deny` suelen aplicarse para restringir el acceso concedido por una política más amplia.
Al denegarse permiso explícitamente se sustituye a cualquier otro permiso concedido. Esto garantiza que las identidades no obtengan accidentalmente permisos que el usuario no desee conceder nunca.
------
#### [ 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"
}
}
}
]
}
```
------
### Ejemplo 3: conceda permiso para acciones en una instancia de base de datos con un nombre de instancia cuyo prefijo sea un nombre de usuario.
La siguiente política da permiso para llamar a cualquier API (salvo `AddTagsToResource` o `RemoveTagsFromResource`) en una instancia de base de datos cuyo prefijo sea un nombre de usuario y que tenga una etiqueta llamada `stage` igual a `devo` o que no tenga ninguna etiqueta llamada `stage`.
La línea `Resource` en la política identifica un recurso por su nombre de recurso de Amazon (ARN). Para obtener más información sobre el uso de ARN con recursos de Amazon RDS, consulte [Nombres de recursos de Amazon (ARN) en 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"
}
}
}
]
}
```
------
# Concesión de permisos para etiquetar recursos de Amazon RDS durante la creación
Algunas operaciones de la API de RDS le permiten especificar etiquetas durante la creación del recurso. Puede utilizar etiquetas de recursos para implementar el control basado en atributos (ABAC). Para obtener más información, consulte ¿[Qué es ABAC para AWS?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) y [Control del acceso a los recursos de AWS mediante etiquetas](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html).
Para permitir que los usuarios etiqueten los recursos durante su creación, es preciso que tengan permisos para utilizar la acción que crea el recurso, por ejemplo `rds:CreateDBInstance`. Si se especifican etiquetas en la acción de creación, RDS realiza una autorización adicional en la acción `rds:AddTagsToResource` para verificar que los usuarios tengan permisos para crear etiquetas. Por lo tanto, los usuarios también deben tener permisos explícitos para usar la acción `rds:AddTagsToResource`.
En la definición de la política de IAM para la acción `rds:AddTagsToResource`, puede utilizar la clave de condición `aws:RequestTag` para requerir etiquetas en una solicitud de etiquetado de un recurso.
Por ejemplo, la siguiente política permite a los usuarios crear instancias de base de datos y aplicar etiquetas durante la creación de instancias de base de datos, pero solo con claves de etiqueta específicas (`environment` o `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"]
}
}
}
]
}
```
------
Esta política deniega cualquier solicitud de creación de instancias de base de datos que incluya etiquetas distintas de las etiquetas `environment` o `project`, o que no especifique ninguna de estas etiquetas. Además, los usuarios deben especificar valores para las etiquetas que coincidan con los valores permitidos en la política.
La siguiente política permite a los usuarios crear clústeres de base de datos y aplicar cualquier etiqueta durante la creación, excepto la etiqueta `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"
}
}
}
]
}
```
------
## Acciones de la API de RDS compatibles para etiquetar durante la creación
Las siguientes acciones de la API de RDS admiten el etiquetado al crear un recurso. Para estas acciones, puede especificar etiquetas al crear el 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`
Si utiliza la AWS CLI o la API para crear un recurso con etiquetas, el parámetro `Tags` se utiliza para aplicar etiquetas a los recursos durante la creación.
En el caso de estas acciones de la API, si se produce un error al etiquetar, el recurso no se crea y se produce un error en la solicitud. Esto garantiza que los recursos se creen con etiquetas o, de lo contrario, no se creen sin las etiquetas correspondientes.
# AWSPolíticas administradas por para Amazon RDS
Para añadir permisos a conjuntos de permisos y roles, es más fácil utilizar políticas administradas de AWS que escribirlas uno mismo. Se necesita tiempo y experiencia para [crear políticas administradas por el cliente de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) que le brinden a su equipo solo los permisos necesarios. Para comenzar rápidamente, puede utilizar nuestras políticas administradas de AWS. Estas políticas cubren casos de uso comunes y están disponibles en su Cuenta de AWS. Para obtener más información acerca de las políticas administradas de AWS, consulte [Políticas administradas de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) en la *Guía del usuario de IAM*.
Los Servicios de AWS mantienen y actualizan las políticas administradas por AWS. No puede cambiar los permisos en las políticas administradas de AWS. En ocasiones, los servicios agregan permisos adicionales a una política administrada de AWS para admitir características nuevas. Este tipo de actualización afecta a todas las identidades (conjuntos de permisos y roles) donde se asocia la política. Es más probable que los servicios actualicen una política administrada de AWScuando se lanza una nueva característica o cuando se ponen a disposición nuevas operaciones. Los servicios no quitan permisos de una política administrada por AWS, por lo que las actualizaciones de políticas no deterioran los permisos existentes.
Además, AWS admite políticas administradas para funciones de trabajo que abarcan varios servicios. Por ejemplo, la política administrada por `ReadOnlyAccess` AWS proporciona acceso de solo lectura a todos los recursos y a Servicios de AWS. Cuando un servicio lanza una nueva característica, AWS agrega permisos de solo lectura para las operaciones y los recursos nuevos. Para obtener una lista y descripciones de las políticas de funciones de trabajo, consulte [Políticas administradas de AWS para funciones de trabajo](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) en la *Guía del usuario de IAM*.
**Topics**
+ [
## Política administrada por:AWS AmazonRDSReadOnlyAccess
](#rds-security-iam-awsmanpol-AmazonRDSReadOnlyAccess)
+ [
## Política administrada por:AWS AmazonRDSFullAccess
](#rds-security-iam-awsmanpol-AmazonRDSFullAccess)
+ [
## Política administrada por:AWS AmazonRDSDataFullAccess
](#rds-security-iam-awsmanpol-AmazonRDSDataFullAccess)
+ [
## Política administrada por:AWS AmazonRDSEnhancedMonitoringRole
](#rds-security-iam-awsmanpol-AmazonRDSEnhancedMonitoringRole)
+ [
## Política administrada por:AWS AmazonRDSPerformanceInsightsReadOnly
](#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsReadOnly)
+ [
## Política administrada por AWS: AmazonRDSPerformanceInsightsFullAccess
](#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsFullAccess)
+ [
## Política administrada por:AWS AmazonRDSDirectoryServiceAccess
](#rds-security-iam-awsmanpol-AmazonRDSDirectoryServiceAccess)
+ [
## Política administrada por:AWS AmazonRDSServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy)
+ [
## Política administrada por:AWS AmazonRDSCustomServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSCustomServiceRolePolicy)
+ [
## Política administrada de:AWS AmazonRDSCustomInstanceProfileRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSCustomInstanceProfileRolePolicy)
+ [
## Política administrada de:AWS AmazonRDSPreviewServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy)
+ [
## Política administrada de:AWS AmazonRDSBetaServiceRolePolicy
](#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy)
## Política administrada por:AWS AmazonRDSReadOnlyAccess
Esta política permite acceso de solo lectura a Amazon RDS mediante la Consola de administración de AWS.
**Detalles de los permisos**
Esta política incluye los permisos siguientes:
+ `rds`: permite a las entidades principales describir los recursos de Amazon RDS y enumerar las etiquetas de los recursos de Amazon RDS.
+ `cloudwatch`: permite a las entidades principales obtener estadísticas de métricas de Amazon CloudWatch.
+ `ec2`: permite a las entidades principales describir las zonas de disponibilidad y los recursos de red.
+ `logs`: permite a las entidades principales describir los flujos de registro de CloudWatch Logs de los grupos de registros y obtener eventos de registro de CloudWatch Logs.
+ `devops-guru`: permite a las entidades principales describir los recursos que incluyen la cobertura de Amazon DevOps Guru, que se especifica mediante nombres de pila o etiquetas de recursos de CloudFormation.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSReadOnlyAccess.html) en la *Guía de referencia de políticas administradas de AWS*.
## Política administrada por:AWS AmazonRDSFullAccess
Esta política proporciona acceso completo a Amazon RDS mediante la Consola de administración de AWS.
**Detalles de los permisos**
Esta política incluye los permisos siguientes:
+ `rds`: permite a las entidades principales obtener acceso completo a Amazon RDS.
+ `application-autoscaling`: permite a las entidades principales describir y administrar los objetivos y las políticas de escalado de Application Auto Scaling.
+ `cloudwatch`: permite a las entidades principales obtener estadísticas métricas de CloudWatch y administrar alarmas de CloudWatch.
+ `ec2`: permite a las entidades principales describir las zonas de disponibilidad y los recursos de red.
+ `logs`: permite a las entidades principales describir los flujos de registro de CloudWatch Logs de los grupos de registros y obtener eventos de registro de CloudWatch Logs.
+ `outposts`: permite a las entidades principales obtener tipos de instancias AWS Outposts.
+ `pi`: permite a las entidades principales obtener métricas de Información sobre rendimiento.
+ `sns`: permite a las entidades principales acceder a las suscripciones y temas de Amazon Simple Notification Service (Amazon SNS), y publicar mensajes de Amazon SNS.
+ `devops-guru`: permite a las entidades principales describir los recursos que incluyen la cobertura de Amazon DevOps Guru, que se especifica mediante nombres de pila o etiquetas de recursos de CloudFormation.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSFullAccess.html) en la *Guía de referencia de políticas administradas de AWS*.
## Política administrada por:AWS AmazonRDSDataFullAccess
Esta política permite tener acceso completo para utilizar la API de datos y el editor de consultas en los clústeres de Aurora Serverless en una Cuenta de AWS determinada. Esta política permite a la Cuenta de AWS obtener el valor de un secreto de AWS Secrets Manager.
Puede adjuntar la política de `AmazonRDSDataFullAccess` a las identidades de IAM.
**Detalles de los permisos**
Esta política incluye los permisos siguientes:
+ `dbqms`: permite a las entidades principales acceder, crear, eliminar, describir y actualizar consultas. El Database Query Metadata Service (`dbqms`) es un servicio únicamente interno. Proporciona sus consultas recientes y guardadas para el editor de consultas en la Consola de administración de AWS para varios servicios de Servicios de AWS, incluido Amazon RDS.
+ `rds-data`: permite a las entidades principales ejecutar instrucciones SQL en bases de datos de Aurora Serverless.
+ `secretsmanager` – permite a las entidades principales obtener el valor de un secreto de AWS Secrets Manager.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSDataFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSDataFullAccess.html) en la *Guía de referencia de políticas administradas de AWS*.
## Política administrada por:AWS AmazonRDSEnhancedMonitoringRole
Esta política proporciona acceso a registros de Amazon Cloudwatch para Supervisión mejorada de Amazon RDS.
**Detalles de los permisos**
Esta política incluye los permisos siguientes:
+ `logs`: permite a las entidades principales crear grupos de registros y políticas de retención de CloudWatch Logs, y crear y describir flujos de registro de CloudWatch Logs de los grupos de registro. También permite a las entidades principales poner y obtener eventos de registro de CloudWatch Logs.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSEnhancedMonitoringRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSEnhancedMonitoringRole.html) en la *Guía de referencia de políticas administradas de AWS*.
## Política administrada por:AWS AmazonRDSPerformanceInsightsReadOnly
Esta política proporciona acceso de solo lectura a Información sobre rendimiento de Amazon RDS para instancias de base de datos de Amazon RDS y clústeres de base de datos de Amazon Aurora.
Ahora, esta política incluye `Sid` (ID de instrucción) como identificador en las instrucciones de la política.
**Detalles de los permisos**
Esta política incluye los permisos siguientes:
+ `rds`: permite a las entidades principales describir instancias de base de datos de Amazon RDS y clústeres de base de datos de Amazon Aurora
+ `pi`: permite a las entidades principales realizar llamadas a la API de Información sobre rendimiento de Amazon RDS y acceder a las métricas de Información sobre rendimiento.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSPerformanceInsightsReadOnly](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPerformanceInsightsReadOnly.html) en la *Guía de referencia de políticas administradas de AWS*.
## Política administrada por AWS: AmazonRDSPerformanceInsightsFullAccess
Esta política proporciona acceso completo a Información de rendimiento de Amazon RDS para instancias de base de datos de Amazon RDS y clústeres de base de datos de Amazon Aurora.
Ahora, esta política incluye `Sid` (ID de instrucción) como identificador en las instrucciones de la política.
**Detalles de los permisos**
Esta política incluye los permisos siguientes:
+ `rds`: permite a las entidades principales describir instancias de base de datos de Amazon RDS y clústeres de base de datos de Amazon Aurora
+ `pi`: permite a los entidades principales realizar llamadas a la API de Información de rendimiento de Amazon RDS y crear, ver y eliminar informes de análisis de rendimiento.
+ `cloudwatch`: permite a las entidades principales enumerar todas las métricas de Amazon CloudWatch y obtener estadísticas y datos de las métricas.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSPerformanceInsightsFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPerformanceInsightsFullAccess.html) en la *Guía de referencia de políticas administradas de AWS*.
## Política administrada por:AWS AmazonRDSDirectoryServiceAccess
Esta política permite a Amazon RDS realizar llamadas al Directory Service.
**Detalles de los permisos**
Esta política incluye el siguiente permiso:
+ `ds`: permite a las entidades principales describir directorios y autorización de control de Directory Service a los directorios de Directory Service.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSDirectoryServiceAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSDirectoryServiceAccess.html) en la *Guía de referencia de políticas administradas de AWS*.
## Política administrada por:AWS AmazonRDSServiceRolePolicy
No puede adjuntar la política `AmazonRDSServiceRolePolicy` a sus entidades de IAM. Esta política está adjunta a un rol vinculado a servicios que permite a Amazon RDS realizar acciones en su nombre. Para obtener más información, consulte [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions).
## Política administrada por:AWS AmazonRDSCustomServiceRolePolicy
No puede adjuntar la política `AmazonRDSCustomServiceRolePolicy` a sus entidades de IAM. Esta política está asociada a un rol vinculado a servicios que permite que Amazon RDS llame a los servicios de AWS en nombre de sus recursos de base de datos de RDS.
Esta política incluye los permisos siguientes:
+ `ec2`: permite a RDS Custom realizar operaciones de copia de seguridad en la instancia de base de datos, lo que proporciona capacidades de restauración en un momento dado.
+ `secretsmanager`: permite a RDS Custom gestionar los secretos específicos de la instancia de base de datos creados por RDS Custom.
+ `cloudwatch`: permite a RDS Custom cargar registros y métricas de instancias de base de datos a CloudWatch a través del agente de CloudWatch.
+ `events`,:`sqs` permite a RDS Custom enviar y recibir información de estado sobre la instancia de base de datos.
+ `cloudtrail`: permite a RDS Custom recibir eventos de cambio sobre la instancia de base de datos
+ `servicequotas`: permite a RDS Custom leer cuotas de servicio relacionadas con la instancia de base de datos
+ `ssm`: permite a RDS Custom administrar la instancia de base de datos subyacente de la instancia de EC2.
+ `rds`: permite a RDS Custom administrar los recursos de RDS para la instancia de base de datos.
+ `iam`: permite a RDS Custom validar y adjuntar el perfil de instancia a la instancia de EC2 subyacente de una instancia de base de datos.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSCustomServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSCustomServiceRolePolicy.html) en la *Guía de referencia de políticas administradas de AWS*.
## Política administrada de:AWS AmazonRDSCustomInstanceProfileRolePolicy
No debe adjuntar `AmazonRDSCustomInstanceProfileRolePolicy` a sus entidades IAM. Solo debe adjuntarse a un rol de perfil de instancia que se utilice para conceder permisos a su instancia de base de datos de Amazon RDS Custom para realizar diversas acciones de automatización y tareas de administración de bases de datos. Transfiera el perfil de instancia como parámetro `custom-iam-instance-profile` durante la creación de la instancia de RDS Custom; RDS Custom asociará este perfil de instancia a su instancia de base de datos.
**Detalles de los permisos**
Esta política incluye los permisos siguientes:
+ `ssm`, `ssmmessages`,:`ec2messages` permite que RDS Custom se comunique, ejecute la automatización y mantenga a los agentes en la instancia de base de datos a través de Systems Manager.
+ `ec2`,:`s3` permite a RDS Custom realizar operaciones de copia de seguridad en la instancia de base de datos, lo que proporciona capacidades de restauración en un momento dado.
+ `secretsmanager`: permite a RDS Custom gestionar los secretos específicos de la instancia de base de datos creados por RDS Custom.
+ `cloudwatch`,:`logs` permite a RDS Custom cargar registros y métricas de instancias de base de datos a CloudWatch a través del agente de CloudWatch.
+ `events`,:`sqs` permite a RDS Custom enviar y recibir información de estado sobre la instancia de base de datos.
+ `kms`: permite a RDS Custom utilizar una clave KMS específica de la instancia para cifrar los secretos y los objetos de S3 que gestiona RDS Custom.
Para obtener más información sobre esta política, lo que incluye el documento de políticas de JSON, consulte [AmazonRDSCustomInstanceProfileRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSCustomInstanceProfileRolePolicy.html), en la *Guía de referencia de la política administrada de AWS*.
## Política administrada de:AWS AmazonRDSPreviewServiceRolePolicy
No debe adjuntar `AmazonRDSPreviewServiceRolePolicy` a sus entidades IAM. Esta política está asociada a un rol vinculado a servicios que permite que Amazon RDS llame a los servicios de AWS en nombre de sus recursos de base de datos de RDS. Para obtener más información, consulte [Rol vinculado a servicios para Amazon RDS Preview](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-rdspreview).
**Detalles de los permisos**
Esta política incluye los permisos siguientes:
+ `ec2`: permite a las entidades principales describir las zonas de disponibilidad y los recursos de red.
+ `secretsmanager` – permite a las entidades principales obtener el valor de un secreto de AWS Secrets Manager.
+ `cloudwatch`,:`logs` permite a Amazon RDS cargar registros y métricas de instancias de base de datos a CloudWatch a través del agente de CloudWatch.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSPreviewServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPreviewServiceRolePolicy.html) en la *Guía de referencia de políticas administradas de AWS*.
## Política administrada de:AWS AmazonRDSBetaServiceRolePolicy
No debe adjuntar `AmazonRDSBetaServiceRolePolicy` a sus entidades IAM. Esta política está asociada a un rol vinculado a servicios que permite que Amazon RDS llame a los servicios de AWS en nombre de sus recursos de base de datos de RDS. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Beta](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-rdsbeta).
**Detalles de los permisos**
Esta política incluye los permisos siguientes:
+ `ec2`: permite a Amazon RDS realizar operaciones de copia de seguridad en la instancia de base de datos, lo que proporciona capacidades de restauración en un momento dado.
+ `secretsmanager`: permite a Amazon RDS gestionar los secretos específicos de la instancia de base de datos creados por Amazon RDS.
+ `cloudwatch`,:`logs` permite a Amazon RDS cargar registros y métricas de instancias de base de datos a CloudWatch a través del agente de CloudWatch.
Para obtener más información sobre esta política, incluido el documento de política de JSON, consulte [AmazonRDSBetaServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSBetaServiceRolePolicy.html) en la *Guía de referencia de políticas administradas de AWS*.
# Actualizaciones de Amazon RDS a políticas administradas por AWS
Es posible consultar los detalles sobre las actualizaciones de las políticas administradas por AWS para Amazon RDS desde que este servicio comenzó a hacer un seguimiento de estos cambios. Para obtener alertas automáticas sobre cambios en esta página, suscríbase a la fuente RSS en la página de [historial de documentos](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/WhatsNew.html) de la API de Amazon RDS.
| Cambio | Descripción | Fecha |
| --- | --- | --- |
| [Política administrada de:AWS AmazonRDSPreviewServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy): actualización de una política actual | Amazon RDS ha eliminado el permiso `sns:Publish` de `AmazonRDSPreviewServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSPreview`. Para obtener más información, consulte [Política administrada de:AWS AmazonRDSPreviewServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy). | 7 de agosto de 2024 |
| [Política administrada de:AWS AmazonRDSBetaServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy): actualización de una política actual | Amazon RDS ha eliminado el permiso `sns:Publish` de `AmazonRDSBetaServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSBeta`. Para obtener más información, consulte [Política administrada de:AWS AmazonRDSBetaServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy). | 7 de agosto de 2024 |
| [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSCustom`. Gracias a los permisos, RDS Custom puede comunicarse con los servicios de Amazon RDS en otra Región de AWS y copiar imágenes de EC2. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 18 de julio de 2024 |
| [Política administrada por:AWS AmazonRDSServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy): actualización de una política actual | Amazon RDS ha eliminado el permiso `sns:Publish` de `AmazonRDSServiceRolePolicy` del rol vinculado a un servicio ` AWSServiceRoleForRDS`. Para obtener más información, consulte [Política administrada por:AWS AmazonRDSServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy). | 2 de julio de 2024 |
| [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSCustom`. Este nuevo permiso permite a RDS Custom asociar un rol de servicio como perfil de instancia a una instancia de RDS Custom. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 19 de abril de 2024 |
| [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md): actualización de una política actual | Amazon RDS agregó un nuevo permiso a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado al servicio `AWSServiceRoleForRDSCustom` para permitir que RDS Custom para SQL Server modifique el tipo de instancia de host de la base de datos subyacente. RDS también agregó el permiso `ec2:DescribeInstanceTypes` para obtener información sobre el tipo de instancia para el host de la base de datos. Para obtener más información, consulte [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md). | 8 de abril de 2024 |
| [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md): política nueva | Amazon RDS agregó una nueva política administrada denominada AmazonRDSCustomInstanceProfileRolePolicy para permitir a RDS Custom realizar acciones de automatización y tareas de administración de bases de datos a través de un perfil de instancia de EC2. Para obtener más información, consulte [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md). | 27 de febrero de 2024 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha agregado nuevos ID de instrucciones a la `AmazonRDSServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDS`. Para obtener más información, consulte [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions). | 19 de enero de 2024 |
| [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md): actualización de políticas existentes | Las políticas administradas `AmazonRDSPerformanceInsightsReadOnly` y `AmazonRDSPerformanceInsightsFullAccess` incluyen ahora `Sid` (ID de instrucción) como identificador en las instrucciones de la política. Para obtener más información, consulte [Política administrada por:AWS AmazonRDSPerformanceInsightsReadOnly](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsReadOnly) y [Política administrada por AWS: AmazonRDSPerformanceInsightsFullAccess](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsFullAccess). | 23 de octubre de 2023 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSCustom`. Estos nuevos permisos permiten que RDS Custom para Oracle cree, modifique y elimine reglas administradas de EventBridge. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 20 de septiembre de 2023 |
| [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la política administrada `AmazonRDSFullAccess`. Los permisos le permiten generar, ver y eliminar el informe de análisis de rendimiento durante un período de tiempo. Para obtener más información sobre la configuración de políticas de acceso para la Información de rendimiento, consulte [Configuración de directivas de acceso para información sobre rendimiento](USER_PerfInsights.access-control.md) | 17 de agosto de 2023 |
| [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md): nueva política y actualización de la política existente | Amazon RDS ha añadido nuevos permisos a la política administrada `AmazonRDSPerformanceInsightsReadOnly` y una nueva política administrada denominada `AmazonRDSPerformanceInsightsFullAccess`. Estos permisos le permiten analizar la Información de rendimiento durante un período de tiempo, ver los resultados del análisis junto con las recomendaciones y eliminar los informes. Para obtener más información sobre la configuración de políticas de acceso para la Información de rendimiento, consulte [Configuración de directivas de acceso para información sobre rendimiento](USER_PerfInsights.access-control.md) | 16 de agosto de 2023 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSCustom`. Estos nuevos permisos permiten que RDS Custom para Oracle utilice instantáneas de bases de datos. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 23 de junio de 2023 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSCustom`. Estos nuevos permisos permiten que RDS Custom para Oracle utilice instantáneas de bases de datos. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 23 de junio de 2023 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSCustom`. Estos nuevos permisos permiten a RDS Custom crear interfaces de red. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 30 de mayo de 2023 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSCustom`. Estos nuevos permisos permiten a RDS Custom llamar a Amazon EBS para comprobar la cuota de almacenamiento. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 18 de abril de 2023 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS Custom ha añadido nuevos permisos a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSCustom` para su integración con Amazon SQS. RDS Custom debe integrarse con Amazon SQS para crear y administrar las colas de SQS en la cuenta del cliente. Los nombres de las colas de SQS siguen el formato `do-not-delete-rds-custom-[identifier]` y se etiquetan con `Amazon RDS Custom`. El permiso para `ec2:CreateSnapshot` también se ha añadido para permitir a RDS Custom crear copias de seguridad de los volúmenes asociados a la instancia. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 6 de abril de 2023 |
| [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md): actualización de una política actual | Amazon RDS ha añadido el espacio de nombres de Amazon CloudWatch `ListMetrics` a `AmazonRDSFullAccess` y `AmazonRDSReadOnlyAccess`. Este espacio de nombres es necesario para que Amazon RDS publique métricas de uso de recursos específicas. Para obtener más información, consulte [Overview of managing access permissions to your CloudWatch resources](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-access-control-overview-cw.html) (Información general sobre la administración de los permisos de acceso a los recursos de CloudWatch) en la *Guía del usuario de Amazon CloudWatch*. | 4 de abril de 2023 |
| [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md): actualización de una política actual | Amazon RDS ha añadido un nuevo permiso a las políticas administradas `AmazonRDSFullAccess` y `AmazonRDSReadOnlyAccess` para permitirle visualizar resultados de Amazon DevOps Guru en la consola de RDS. Este permiso es necesario para poder mostrar los resultados de DevOps Guru. Para obtener más información, consulte [ Amazon RDS updates to AWS managed policies](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-manpol-updates.html) (Actualizaciones de Amazon RDS de las políticas administradas de AWS). | 30 de marzo de 2023 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la `AmazonRDSServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDS` para su integración con AWS Secrets Manager. RDS debe integrarse con Secrets Manager para administrar las contraseñas de los usuarios maestros en Secrets Manager. El secreto utiliza una convención de nomenclatura reservada y restringe las actualizaciones de los clientes. Para obtener más información, consulte [Administración de contraseñas con Amazon RDS y AWS Secrets Manager](rds-secrets-manager.md). | 22 de diciembre de 2022 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos permisos a la `AmazonRDSCustomServiceRolePolicy` del rol vinculado a un servicio `AWSServiceRoleForRDSCustom`. RDS Custom admite clústeres de bases de datos. Estos nuevos permisos de la política permiten a RDS Custom llamar a Servicios de AWS en nombre de sus clústeres de bases de datos. Para obtener más información, consulte [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom). | 9 de noviembre de 2022 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos permisos al rol vinculado a un servicio `AWSServiceRoleForRDS` de integración con AWS Secrets Manager. La integración con Secrets Manager es necesaria para que el correo electrónico de SQL Server Reporting Services (SSRS) funcione en RDS. El correo electrónico de SSRS crea un secreto en nombre del cliente. El secreto utiliza una convención de nomenclatura reservada y restringe las actualizaciones de los clientes. Para obtener más información, consulte [Uso del correo electrónico de SSRS para enviar informes](SSRS.Email.md). | 26 de agosto de 2022 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos espacios de nombres de Amazon CloudWatch a `AmazonRDSPreviewServiceRolePolicy` para `PutMetricData`. Este espacio de nombres es necesario para que Amazon RDS publique métricas de uso de recursos. Para obtener más información, consulte [Uso de claves de condición para limitar el acceso a los espacios de nombres de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) en la *guía del usuario de Amazon CloudWatch*. | 7 de junio de 2022 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos espacios de nombres de Amazon CloudWatch a `AmazonRDSBetaServiceRolePolicy` para `PutMetricData`. Este espacio de nombres es necesario para que Amazon RDS publique métricas de uso de recursos. Para obtener más información, consulte [Uso de claves de condición para limitar el acceso a los espacios de nombres de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) en la *guía del usuario de Amazon CloudWatch*. | 7 de junio de 2022 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos espacios de nombres de Amazon CloudWatch a `AWSServiceRoleForRDS` para `PutMetricData`. Este espacio de nombres es necesario para que Amazon RDS publique métricas de uso de recursos. Para obtener más información, consulte [Uso de claves de condición para limitar el acceso a los espacios de nombres de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) en la *guía del usuario de Amazon CloudWatch*. | 22 de abril de 2022 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos permisos al rol vinculado al servicio de `AWSServiceRoleForRDS` para administrar los permisos de los grupos de IP propiedad del cliente y las tablas de enrutamiento de puerta de enlace local (LGW-RTB). Estos permisos son necesarios para que RDS on Outposts realice una replicación Multi-AZ en toda la red local de Outposts. Para obtener más información, consulte [Trabajo con implementaciones Multi-AZ para Amazon RDS on AWS Outposts](rds-on-outposts.maz.md). | 19 de abril de 2022 |
| [Políticas basadas en identidades](UsingWithRDS.IAM.md#security_iam_access-manage-id-based-policies): actualización de una política actual | Amazon RDS ha añadido un nuevo permiso a la política administrada por `AmazonRDSFullAccess` para describir los permisos en LGW-RTB. Este permiso es necesario para que RDS on Outposts realice una replicación Multi-AZ en toda la red local de Outposts. Para obtener más información, consulte [Trabajo con implementaciones Multi-AZ para Amazon RDS on AWS Outposts](rds-on-outposts.maz.md). | 19 de abril de 2022 |
| [AWSPolíticas administradas por para Amazon RDS](rds-security-iam-awsmanpol.md): política nueva | Amazon RDS ha añadido una nueva política administrada llamada `AmazonRDSPerformanceInsightsReadOnly` para permitir que Amazon RDS llame a servicios de AWS en nombre de sus instancias de bases de datos. Para obtener más información sobre la configuración de políticas de acceso para la Información de rendimiento, consulte [Configuración de directivas de acceso para información sobre rendimiento](USER_PerfInsights.access-control.md) | 10 de marzo de 2022 |
| [Permisos de roles vinculados a servicios de Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): actualización de una política actual | Amazon RDS ha añadido nuevos espacios de nombres de Amazon CloudWatch a `AWSServiceRoleForRDS` para `PutMetricData`. Estos espacios de nombres son necesarios para Amazon DocumentDB (compatible con MongoDB) y Amazon Neptune para publicar métricas de CloudWatch. Para obtener más información, consulte [Uso de claves de condición para limitar el acceso a los espacios de nombres de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) en la *guía del usuario de Amazon CloudWatch*. | 4 de marzo de 2022 |
| [Permisos de roles vinculados a servicios para Amazon RDS Custom](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-custom): política nueva | Amazon RDS ha agregado un nuevo rol vinculado al servicio llamado `AWSServiceRoleForRDSCustom` para permitir que RDS Custom llame a Servicios de AWS en nombre de las instancias de bases de datos. | 26 de octubre de 2021 |
| Amazon RDS ha comenzado a hacer un seguimiento de los cambios | Amazon RDS ha comenzado a realizar un seguimiento de los cambios en sus políticas administradas por AWS. | 26 de octubre de 2021 |
# Prevención de los problemas del suplente confuso entre servicios
El *problema de la sustitución confusa* es un problema de seguridad en el que una entidad que no tiene permiso para realizar una acción puede obligar a una entidad con más privilegios a realizar la acción. En AWS, la suplantación entre servicios puede dar lugar al problema de la sustitución confusa.
La suplantación entre servicios puede producirse cuando un servicio (el *servicio que lleva a cabo las llamadas*) llama a otro servicio (el *servicio al que se llama*). El servicio que lleva a cabo las llamadas se puede manipular para utilizar sus permisos a fin de actuar en función de los recursos de otro cliente de una manera en la que no debe tener permiso para acceder. Para evitarlo, AWS proporciona herramientas que pueden ayudarlo a proteger sus datos en todos los servicios con entidades principales de servicio a las que se les ha dado acceso a los recursos de su cuenta. Para obtener más información, consulte [El problema del suplente confuso](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) en la *Guía del usuario de IAM*.
A fin de limitar los permisos que Amazon RDS da a otro servicio para un recurso específico, le recomendamos utilizar las claves de contexto de condición global de [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) y [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) en las políticas de recursos.
En algunos casos, el valor de `aws:SourceArn` no contiene el ID de la cuenta, por ejemplo, al utilizar el nombre de recurso de Amazon (ARN) para un bucket de Simple Storage Service (Amazon S3). En estos casos, asegúrese de utilizar ambas claves de contexto de condición global para limitar los permisos. En algunos casos, se utilizan las claves de contexto de condición global y el valor de `aws:SourceArn` contiene el ID de la cuenta. En estos casos, asegúrese de que el valor de `aws:SourceAccount` y la cuenta en `aws:SourceArn` utilicen el mismo ID de cuenta cuando se utilizan en la misma instrucción de política. Si quiere que solo se asocie un recurso al acceso entre servicios, utilice `aws:SourceArn`. Si quiere permitir que cualquier recurso de esa cuenta de AWS se asocie al uso entre servicios, utilice `aws:SourceAccount`.
Asegúrese de que el valor de `aws:SourceArn` sea un ARN para un tipo de recurso de Amazon RDS. Para obtener más información, consulte [Nombres de recursos de Amazon (ARN) en Amazon RDS](USER_Tagging.ARN.md).
La forma más eficaz de protegerse contra el problema del suplente confuso es utilizar la clave de contexto de condición global de `aws:SourceArn` con el ARN completo del recurso. En algunos casos, es posible que no sepa el ARN completo del recurso o que esté especificando varios recursos. En estos casos, utilice la clave de condición de contexto global de `aws:SourceArn` con comodines (`*`) para las partes desconocidas del ARN. Un ejemplo es `arn:aws:rds:*:123456789012:*`.
En el ejemplo siguiente, se muestra cómo se pueden utilizar las claves de contexto de condición global de `aws:SourceArn` y `aws:SourceAccount` en Amazon RDS para evitar el problema del suplente 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 ver más ejemplos de las políticas que utilizan las claves de contexto de condición global de `aws:SourceArn` y `aws:SourceAccount`, consulte las siguientes secciones:
+ [Concesión de permisos para publicar notificaciones en un tema de Amazon SNS](USER_Events.GrantingPermissions.md)
+ [Creación manual de un rol de IAM para la copia de seguridad y la restauración nativas](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ [Configuración de la autenticación de Windows para las instancias de base de datos de SQL Server](USER_SQLServerWinAuth.SettingUp.md)
+ [Requisitos previos para la integración de RDS for SQL Server con S3](Appendix.SQLServer.Options.S3-integration.preparing.md)
+ [Creación manual de un rol de IAM para SQL Server Audit](Appendix.SQLServer.Options.Audit.IAM.md)
+ [Configuración de permisos IAM para la integración de RDS para Oracle con Amazon S3](oracle-s3-integration.preparing.md)
+ [Configuración del acceso a un bucket de Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md) (importación de PostgreSQL)
+ [Configuración del acceso a un bucket de Amazon S3](postgresql-s3-export-access-bucket.md) (exportación de PostgreSQL)
# Autenticación de bases de datos de IAM para MariaDB, MySQL, and PostgreSQL
Puede autenticar en su instancia mediante la autenticación de base de datos de AWS Identity and Access Management (IAM). La autenticación de base de datos de IAM funciona con MariaDB, MySQL y PostgreSQL. Con este método de autenticación, no es necesario usar una contraseña al conectarse a una instancia. En su lugar, puede usar un token de autenticación.
Un *token de autenticación* es una cadena única de caracteres que genera Amazon RDS bajo demanda. Los tokens de autenticación se generan mediante AWS Signature versión 4. Cada token tiene una vida útil de 15 minutos. No es necesario almacenar credenciales de usuario en la base de datos, ya que la autenticación se administra de forma externa mediante IAM. También puede seguir utilizando la autenticación de base de datos estándar. El token solo se utiliza para la autenticación y no afecta a la sesión después de establecerse.
La autenticación de bases de datos de IAM proporciona los siguientes beneficios:
+ El tráfico de red hacia y desde la base de datos se cifra mediante Secure Socket Layer (SSL) o Transport Layer Security (TLS). Para obtener más información sobre el uso de SSL/TLS con Amazon RDS, consulte [Uso de SSL/TLS para cifrar una conexión a una instancia o un clúster de base de datos](UsingWithRDS.SSL.md).
+ Puede usar IAM para administrar de forma centralizada el acceso a sus recursos de base de datos, en lugar de administrar el acceso individualmente en cada instancia.
+ Para las aplicaciones que se ejecutan en Amazon EC2, puede usar las credenciales del perfil específicas de la instancia de EC2 para obtener acceso a su base de datos en lugar de una contraseña, para mayor seguridad.
En general, considere la posibilidad de utilizar la autenticación de base de datos de IAM cuando sus aplicaciones creen menos de 200 conexiones por segundo y no desee administrar los nombres de usuario y las contraseñas directamente en el código de la aplicación.
El controlador JDBC de Amazon Web Services (AWS) admite la autenticación de base de datos de IAM. Para obtener más información, consulte [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) en el [repositorio GitHub del controlador JDBC de Amazon Web Services (AWS)](https://github.com/aws/aws-advanced-jdbc-wrapper).
El controlador de Python de Amazon Web Services (AWS) admite la autenticación de base de datos de IAM. Para obtener más información, consulte [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) en el [repositorio GitHub del controlador de Python de Amazon Web Services (AWS)](https://github.com/aws/aws-advanced-python-wrapper).
Consulte los siguientes temas para aprender a utilizar el proceso de configuración de IAM para la autenticación de bases de datos:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Conexión a la instancia con la autenticación de IAM](UsingWithRDS.IAMDBAuth.Connecting.md)
## Disponibilidad en regiones y versiones
La disponibilidad y el soporte de las características varía según las versiones específicas de cada motor de base de datos. Para obtener más información sobre la disponibilidad de motor, versión y región con Amazon RDS y la autenticación de base de datos de IAM, consulte [Regiones y motores de base de datos admitidos para autenticación de base de datos IAM en Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.IamDatabaseAuthentication.md).
## Soporte de CLI y SDK
La autenticación de bases de datos de IAM está disponible para la [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html) y para los siguientes SDK de AWS específicos para cada lenguaje:
+ [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)
## Restricciones a la autenticación de bases de datos de IAM
Si utiliza la autenticación de base de datos de IAM, se aplicarán las siguientes limitaciones:
+ Actualmente, la autenticación de base de datos de IAM no admite todas las claves de contexto de condición global.
Para obtener más información sobre las claves de condición globales, consulte [Claves de contexto de condición globales de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) en la *Guía del usuario de IAM*.
+ Para PostgreSQL, si se agrega el rol de IAM (`rds_iam`) a un usuario (incluido el usuario maestro de RDS), la autenticación de IAM tiene prioridad sobre la autenticación de la contraseña, por lo que el usuario debe iniciar sesión como un usuario de IAM.
+ Para PostgreSQL, Amazon RDS no admite habilitar los métodos de autenticación de IAM y Kerberos al mismo tiempo.
+ Para PostgreSQL, no puede utilizar la autenticación de IAM para establecer una conexión de replicación.
+ No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión de la instancia de base de datos para generar el token de autenticación.
+ CloudWatch y CloudTrail no registran la autenticación de IAM. Estos servicios no rastrean las llamadas a la API `generate-db-auth-token` que autorizan a la función de IAM a habilitar la conexión a la base de datos.
+ La autenticación de la base de datos de IAM requiere recursos informáticos en la instancia de la base de datos. Debe tener entre 300 MiB y 1000 MiB de memoria adicional en la base de datos para obtener una conectividad fiable. Para ver la memoria necesaria para la carga de trabajo, compare la columna RES de los procesos RDS en la lista de procesos de supervisión mejorada antes y después de habilitar la autenticación de bases de datos de IAM. Consulte [Visualización de métricas OS en la consola de RDS](USER_Monitoring.OS.Viewing.md).
Si está utilizando una instancia de clase ampliable, evite quedarse sin memoria mediante la reducción de la memoria utilizada por otros parámetros como búferes y caché en la misma cantidad.
+ La autenticación de base de datos de IAM no es compatible con RDS en Outposts para ningún motor.
## Recomendaciones para la autenticación de base de datos de IAM
Recomendamos lo siguiente cuando se utiliza la autenticación de base de datos de IAM:
+ Utilice la autenticación de base de datos de IAM cuando la aplicación necesite menos de 200 conexiones nuevas por segundo para la autenticación de bases de datos de IAM.
Los motores de base de datos que funcionan con Amazon RDS no imponen ninguna restricción a los intentos de autenticación por segundo. Sin embargo, al usar la autenticación de bases de datos de IAM, su aplicación debe generar un token de autenticación. A continuación, su aplicación usa ese token para conectarse a la instancia. Si supera el límite máximo de nuevas conexiones por segundo, la sobrecarga adicional de la autenticación de bases de datos de IAM puede dar lugar a la limitación controlada de las conexiones.
Considere la posibilidad de utilizar la agrupación de conexiones en sus aplicaciones para mitigar la creación constante de conexiones. Esto puede reducir la sobrecarga de la autenticación de bases de datos de IAM y permitir que las aplicaciones reutilicen las conexiones existentes. De forma alternativa, también puede utilizar RDS Proxy para estos casos de uso. RDS Proxy tiene costos adicionales. Consulte los [precios de RDS Proxy](https://aws.amazon.com/rds/proxy/pricing/).
+ El tamaño de un token de autenticación de base de datos de IAM depende de muchos factores, como la cantidad de etiquetas de IAM, las políticas de servicio de IAM, las longitudes del ARN y otras propiedades de IAM y de la base de datos. El tamaño mínimo de este token suele ser de aproximadamente 1 KB, pero puede ser mayor. Dado que este token se utiliza como contraseña en la cadena de conexión a la base de datos mediante la autenticación de IAM, debe asegurarse de que ni el controlador de la base de datos (por ejemplo, ODBC) ni ninguna herramienta limiten ni trunquen de otro modo este token debido a su tamaño. Un token truncado provocará un error en la validación de autenticación que realiza la base de datos e IAM.
+ Si utiliza credenciales temporales al crear un token de autenticación de base de datos de IAM, las credenciales temporales deben seguir siendo válidas cuando utilice el token de autenticación de base de datos de IAM para realizar una solicitud de conexión.
## Claves de contexto de condición globales de AWS admitidas
La autenticación de base de datos de IAM no admite el siguiente subconjunto de claves de contexto de condición globales de AWS.
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`
Para obtener más información, consulte [Claves de contexto de condición globales de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) en la *Guía del usuario de IAM*.
# Activación y desactivación de la autenticación de bases de datos de IAM
De forma predeterminada, la autenticación de bases de datos de IAM está deshabilitada en las instancias de base de datos. Puede activar o desactivar la autenticación de bases de datos de IAM mediante la Consola de administración de AWS, la AWS CLI o la API.
Puede habilitar la autenticación de base de datos de IAM cuando realice una de las siguientes acciones:
+ Para crear una nueva instancia de base de datos con la autenticación de base de datos de IAM activada, consulte [Creación de una instancia de base de datos de Amazon RDS](USER_CreateDBInstance.md).
+ Para modificar una instancia de base de datos para activar la autenticación de base de datos de IAM, consulte [Modificación de una instancia de base de datos de Amazon RDS](Overview.DBInstance.Modifying.md).
+ Para restaurar una instancia de bases de datos a partir de una instantánea con la autenticación de base de datos de IAM activada, consulte [Restauración a una instancia de base de datos](USER_RestoreFromSnapshot.md).
+ Para restaurar una instancia de base de datos a un momento dado con la autenticación de base de datos de IAM habilitada, consulte [Restauración de una instancia de base de datos a un momento especificado para Amazon RDS](USER_PIT.md).
## Consola
Cada flujo de trabajo de creación o modificación tiene una sección **Database authentication (Autenticación de base de datos)**, donde puede activar o desactivar la autenticación de base de datos de IAM. En esa sección, elija **Password and IAM database authentication (Autenticación de bases de datos con contraseña e IAM)** para activar la autenticación de base de datos de IAM.
**Para activar o desactivar la autenticación de IAM para una instancia existente**
1. Abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, seleccione **Databases (Bases de datos)**.
1. Elija la instancia que desea modificar.
**nota**
Asegúrese de que la instancia de base de datos sea compatible con la autenticación de IAM. Compruebe los requisitos de compatibilidad en [Disponibilidad en regiones y versiones](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
1. Elija **Modify**.
1. En la sección **Autenticación de base de datos**, elija **Autenticación de bases de datos de contraseña e IAM** para habilitar la autenticación de bases de datos de IAM. Elija **Autenticación con contraseña** o **Contraseña y autenticación Kerberos** para deshabilitar la autenticación de IAM.
1. También puede elegir habilitar la publicación de registros de autenticación de bases de datos de IAM en Registros de CloudWatch. En **Exportaciones de registros**, elija la opción **registro iam-db-auth-error**. La publicación de los registros en Registros de CloudWatch consume almacenamiento y se generan cargos por dicho almacenamiento. Asegúrese de eliminar los Registros de CloudWatch que ya no necesite.
1. Elija **Continue**.
1. Para aplicar los cambios inmediatamente, elija **Immediately (Inmediatamente)** en la sección **Scheduling of modifications (Programación de modificaciones)**.
1. Elija **Modify DB instance (Modificar instancia de base de datos)** .
## AWS CLI
Para crear una instancia de base de datos nueva con la autenticación de IAM mediante la AWS CLI, use el 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 la opción `--enable-iam-database-authentication`, como se muestra en el siguiente ejemplo.
```
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 actualizar una instancia de base de datos existente para que tenga o no tenga autenticación de IAM, utilice el comando [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) de la `modify-db-instance`. Especifique la opción `--enable-iam-database-authentication` o `--no-enable-iam-database-authentication`, como proceda.
**nota**
Asegúrese de que la instancia de base de datos sea compatible con la autenticación de IAM. Compruebe los requisitos de compatibilidad en [Disponibilidad en regiones y versiones](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
De forma predeterminada, Amazon RDS realiza la modificación durante el siguiente periodo de mantenimiento. Si desea invalidar esto y habilitar la autenticación de bases de datos de IAM lo antes posible, use el parámetro `--apply-immediately`.
En el siguiente ejemplo se muestra cómo habilitar inmediatamente la autenticación de IAM para una instancia de base de datos existente.
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--apply-immediately \
--enable-iam-database-authentication
```
Si restaura una instancia, use uno de los siguientes comandos de AWS CLI:
+ `[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)`
De forma predeterminada, la configuración de la autenticación de bases de datos de IAM será la de la instantánea de origen. Para cambiar esta configuración, establezca la opción `--enable-iam-database-authentication` o `--no-enable-iam-database-authentication`, como proceda.
## API de RDS
Para crear una instancia de base de datos nueva con la autenticación de IAM mediante la API, use la operación de la API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Defina el parámetro `EnableIAMDatabaseAuthentication` como `true`.
Para actualizar una instancia de base de datos existente para que tenga o no tenga autenticación de IAM, utilice la operación de la API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html). Establezca el parámetro `EnableIAMDatabaseAuthentication` en `true` para habilitar la autenticación de IAM o en `false` para deshabilitarla.
**nota**
Asegúrese de que la instancia de base de datos sea compatible con la autenticación de IAM. Compruebe los requisitos de compatibilidad en [Disponibilidad en regiones y versiones](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Si restaura una instancia, use una de las siguientes operaciones de la API:
+ [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)
De forma predeterminada, la configuración de la autenticación de bases de datos de IAM será la de la instantánea de origen. Para cambiar esta configuración, establezca el parámetro `EnableIAMDatabaseAuthentication` en `true` para habilitar la autenticación de IAM o `false` para deshabilitarla.
# Creación y uso de una política de IAM para el acceso a bases de datos de IAM
Para permitir a un usuario o rol conectarse a su instancia de base de datos, debe crear una política de IAM. Después de eso, puede asociar la política a un conjunto de permisos o un rol.
**nota**
Para obtener más información acerca de las políticas de IAM, consulte [Administración de la identidad y el acceso en Amazon RDS](UsingWithRDS.IAM.md).
La siguiente política de ejemplo permite a un usuario conectarse a una instancia de base de datos mediante la autenticación de bases de datos de 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**
Un usuario con permisos de administrador puede acceder a las instancias de base de datos sin permiso explícito en una política de IAM. Si desea restringir el acceso del administrador a los de instancias de base de datos, puede crear un rol de IAM con los permisos privilegiados menores y asignarlo al administrador.
**nota**
No confunda el prefijo `rds-db:` con otros prefijos de operación de la API de RDS que empiezan por `rds:`. Puede usar el prefijo `rds-db:` y la acción `rds-db:connect` solo para la autenticación de bases de datos de IAM. No son válidos en ningún otro contexto.
La política de ejemplo incluye una sola instrucción con los siguientes elementos:
+ `Effect`: especifique `Allow` para conceder acceso a la instancia. Si no permite el acceso de forma explícita, el acceso se deniega de forma predeterminada.
+ `Action`: especifique `rds-db:connect` para permitir las conexiones a la instancia.
+ `Resource`: especifique un nombre de recurso de Amazon (ARN) que describa una cuenta de base de datos en una instancia. El formato del ARN es el siguiente.
```
arn:aws:rds-db:region:account-id:dbuser:DbiResourceId/db-user-name
```
En este formato, reemplace lo siguiente:
+ `region` es la región de AWS para la instancia y . En la política de ejemplo, la región de AWS es `us-east-2`.
+ `account-id` es el número de cuenta de AWS para la instancia y . En la política de ejemplo, el número de cuenta es `1234567890`. El usuario debe estar en la misma cuenta que la cuenta de la instancia de base de datos.
Para realizar el acceso entre cuentas, cree un rol de IAM con la política que se muestra arriba en la cuenta para la instancia de base de datos y permita que su otra cuenta asuma el rol.
+ `DbiResourceId` es el identificador de la instancia. Este identificador es único para una región de AWS y nunca cambia. En la política de ejemplo, el identificador es `db-ABCDEFGHIJKL01234`.
Para buscar un ID de recurso de instancia de bases de datos en la Consola de administración de AWS de Amazon RDS, elija la instancia de bases de datos para ver los detalles. A continuación, elija la pestaña **Configuration (Configuración)**. El **Resource ID (ID de recurso)** se muestra en la sección **Configuration (Configuración)**.
También puede usar el comando de la AWS CLI para enumerar los identificadores e ID de recurso para todas sus instancias y de base de datos en la región de AWS actual, como se muestra a continuación.
```
aws rds describe-db-instances --query "DBInstances[*].[DBInstanceIdentifier,DbiResourceId]"
```
Si utiliza Amazon Aurora, especifique un `DbClusterResourceId` en lugar de un `DbiResourceId`. Para obtener más información, consulte [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html) en la *Guía del usuario de Amazon Aurora*.
**nota**
Si se está conectando a una base de datos a través del proxy de RDS, especifique el ID del recurso proxy; por ejemplo, `prx-ABCDEFGHIJKL01234`. Para obtener información sobre el uso de la autenticación de bases de datos de IAM con el proxy de RDS, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
+ `db-user-name` es el nombre de la cuenta de base de datos que se asociará a la autenticación de IAM. En la política de ejemplo, la cuenta de base de datos es `db_user`.
Puede crear otros ARN que admitan diversos patrones de acceso. La siguiente política permite el acceso a dos cuentas de base de datos diferentes en una instancia de base de datos.
------
#### [ 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"
]
}
]
}
```
------
La siguiente política usa el carácter "\$1" a fin de buscar coincidencias con todas las instancias y de base de datos y cuentas de base de datos para una cuenta de AWS y una región de AWS determinadas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:*/*"
]
}
]
}
```
------
La siguiente política busca coincidencias con todas las instancias y de base de datos para una cuenta de AWS y una región de AWS determinadas. Sin embargo, la política solo concede acceso a instancias de base de datos que tienen una cuenta de base de datos `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"
]
}
]
}
```
------
El usuario o el rol solo tiene acceso a las mismas bases de datos que el usuario de la base de datos. Por ejemplo, suponga que su instancia tiene una base de datos denominada *dev* y otra llamada *test*. Si el usuario de base de datos `jane_doe` solo tiene acceso a *dev*, cualquier usuario o rol que obtenga acceso a esa instancia de base de datos con el usuario `jane_doe` también tendrá acceso únicamente a *dev*. Esta restricción del acceso también se aplica a otros objetos de la base de datos tales como tablas, vistas, etc.
Un administrador debe crear políticas de IAM que concedan permisos a las entidades para realizar operaciones de la API concretas en los recursos especificados que necesiten. El administrador debe asociar esas políticas a los conjuntos de permisos o roles que necesiten esos permisos. Para ver algunos ejemplos de políticas, consulte [Ejemplos de políticas basadas en identidad para Amazon RDS](security_iam_id-based-policy-examples.md).
## Asociación de una política de IAM a un conjunto de permisos o un rol
Tras crear una política de IAM que permita la autenticación de bases de datos, es necesario asociar la política a un conjunto de permisos o un rol. Para ver un tutorial acerca de este tema, consulte [ Crear y asociar su primera política administrada por el cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) en la *Guía del usuario de IAM*.
Mientras realiza el tutorial, puede usar uno de los ejemplos de política mostrados en esta sección como punto de partida y adaptarlo a sus necesidades. Al final del tutorial, tiene un conjunto de permisos con una política asociada que puede utilizar la acción `rds-db:connect`.
**nota**
Puede asignar varios conjuntos de permisos o roles a la misma cuenta de usuario de base de datos. Por ejemplo, suponga que su política de IAM ha especificado el siguiente ARN del recurso.
```
arn:aws:rds-db:us-east-2:123456789012:dbuser:db-12ABC34DEFG5HIJ6KLMNOP78QR/jane_doe
```
Si adjunta la política a los usuarios *Jane*, *Bob* y *Diego*, cada uno de esos usuarios puede conectarse a la instancia especificada de base de datos por medio de la cuenta de la base de datos de `jane_doe`.
# Creación de cuentas de base de datos utilizando autenticación de IAM
Con la autenticación de bases de datos de IAM, no es necesario asignar contraseñas de la base de datos a las cuentas de usuario creadas. Si quita un usuario asignado a una cuenta de base de datos, también debe quitar la cuenta de base de datos con la instrucción `DROP USER`.
**nota**
El nombre de usuario utilizado para la autenticación de IAM debe coincidir con el nombre de usuario en la base de datos.
**Topics**
+ [
## Uso de la autenticación de IAM con MariaDB y MySQL
](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [
## Uso de la autenticación de IAM con PostgreSQL
](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## Uso de la autenticación de IAM con MariaDB y MySQL
Con MariaDB y MySQL, `AWSAuthenticationPlugin` gestiona la autenticación. Se trata de un complemento proporcionado por AWS que funciona perfectamente con IAM para autenticar a sus usuarios. Conecte al de instancias de base de datos como usuario maestro o como usuario diferente que pueda crear usuarios y conceder privilegios. Tras la conexión, lance la instrucción `CREATE USER`, tal como se muestra en el siguiente ejemplo.
```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS';
```
La cláusula `IDENTIFIED WITH` permite que MariaDB y MySQL usen `AWSAuthenticationPlugin` para autenticar la cuenta de base de datos (`jane_doe`). La cláusula de `AS 'RDS'` hace referencia al método de autenticación. Asegúrese de que el nombre de usuario de la base de datos especificado sea igual a un recurso de la política de IAM para el acceso a la base de datos de IAM. Para obtener más información, consulte [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md).
**nota**
Si ve el siguiente mensaje, significa que el complemento proporcionado por AWS no está disponible para la instanciay actual.
`ERROR 1524 (HY000): Plugin 'AWSAuthenticationPlugin' is not loaded`
Para identificar este error, verifique que usa una configuración admitida y que ha habilitado la autenticación de bases de datos de IAM en su instancia. Para obtener más información, consulte [Disponibilidad en regiones y versiones](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) y [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md).
Después de crear una cuenta mediante `AWSAuthenticationPlugin`, puede administrarla de la misma forma que otras cuentas de base de datos. Por ejemplo, puede modificar los privilegios de cuenta con las instrucciones `GRANT` y `REVOKE`, o bien modificar diversos atributos de cuenta con la instrucción `ALTER USER`.
El tráfico de la red de la base de datos se cifra mediante SSL/TLS cuando se utiliza IAM. Para permitir las conexiones SSL, modifique la cuenta de usuario con el siguiente comando.
```
ALTER USER 'jane_doe'@'%' REQUIRE SSL;
```
## Uso de la autenticación de IAM con PostgreSQL
Para usar la autenticación de IAM con PostgreSQL, conéctese a la instancia de base de datos como usuario maestro o como usuario diferente que pueda crear usuarios y conceder privilegios. Tras la conexión, cree usuarios de base de datos y, a continuación, concédales el rol `rds_iam` tal como se muestra en el siguiente ejemplo.
```
CREATE USER db_userx;
GRANT rds_iam TO db_userx;
```
Asegúrese de que el nombre de usuario de la base de datos especificado sea igual a un recurso de la política de IAM para el acceso a la base de datos de IAM. Para obtener más información, consulte [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Debe conceder el rol `rds_iam` para utilizar la autenticación de IAM. También puede utilizar suscripciones anidadas o concesiones indirectas del rol.
# Conexión a la instancia con la autenticación de IAM
Con la autenticación de bases de datos de IAM, puede usar un token de autenticación al conectarse a su instancia. Un *token de autenticación* es una cadena de caracteres que usa en lugar de una contraseña. Después de generar un token de autenticación, será válido durante 15 minutos antes de caducar. Si intenta conectarse mediante un token caducado, la solicitud de conexión se deniega.
Todos los tokens de autenticación deben ir acompañados de una firma válida, mediante AWS Signature versión 4. (Para obtener más información, consulte [Proceso de firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) en la* Referencia general de AWS.*). AWS CLI y un SDK de AWS, como AWS SDK para Java o AWS SDK para Python (Boto3), pueden firmar automáticamente cada token que cree.
Puede utilizar un token de autenticación cuando se conecte a Amazon RDS desde otro servicio de AWS, como AWS Lambda. Al utilizar un token, puede evitar introducir una contraseña en el código. De forma opcional, puede usar un SDK de AWS para crear y firmar mediante programación un token de autenticación.
Una vez que tenga un token de autenticación de IAM firmado, podrá conectarse a una instancia de base de datos de Amazon RDS. A continuación, puede aprender cómo hacer esto mediante una herramienta de línea de comandos o un SDK de AWS, como AWS SDK para Java o AWS SDK para Python (Boto3).
Para obtener más información, consulte las siguientes entradas del blog:
+ [Use IAM authentication to connect with SQL Workbench/J to Aurora MySQL or Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/)
+ [Using IAM authentication to connect with pgAdmin Amazon Aurora PostgreSQL or Amazon RDS para PostgreSQL (Usar la autenticación de IAM para conectar pgAdmin con Amazon Aurora PostgreSQL o 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/)
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al de instancia de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [
# Conexión a su de instancia de base de datos mediante la autenticación IAM con los controladores de AWS
](IAMDBAuth.Connecting.Drivers.md)
+ [
# Conexión a su instancia con autenticación de IAM desde la línea de comandos: AWS CLI y cliente de MySQL
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [
# Conexión a su instancia desde la línea de comandos: AWS CLI y psql Client
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [
# Conexión la instancia de base de datos mediante la autenticación de IAM y el AWS SDK para .NET
](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [
# Conexión la instancia de base de datos mediante la autenticación de IAM y el AWS SDK para Go
](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [
# Conexión la instancia de base de datos mediante la autenticación de IAM y el AWS SDK para Java
](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [
# Conexión la instancia de base de datos mediante la autenticación de IAM y el AWS SDK para Python (Boto3)
](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# Conexión a su de instancia de base de datos mediante la autenticación IAM con los controladores de AWS
El conjunto de controladores de AWS se ha diseñado para permitir tiempos de transición y conmutación por error más rápidos y autenticarse con AWS Secrets Manager, AWS Identity and Access Management (IAM) e identidad federada. Los controladores de AWS se basan en la supervisión del estado de la instancia de base de datos y en el conocimiento de la topología de la instancia para determinar quién es el nuevo escritor. Este enfoque reduce los tiempos de transición y conmutación por error a segundos de un solo dígito, en comparación con las decenas de segundos de los controladores de código abierto.
Para obtener más información sobre los controladores de AWS, consulte el controlador de idioma correspondiente de su instancia de base de datos [RDS para MariaDB](MariaDB.Connecting.Drivers.md#MariaDB.Connecting.JDBCDriver), [RDS para MySQL](MySQL.Connecting.Drivers.md#MySQL.Connecting.JDBCDriver) o [RDS para PostgreSQL](PostgreSQL.Connecting.JDBCDriver.md).
**nota**
Las únicas características que se admiten con RDS para MariaDB son la autenticación con AWS Secrets Manager, AWS Identity and Access Management (IAM) y la identidad federada.
# Conexión a su instancia con autenticación de IAM desde la línea de comandos: AWS CLI y cliente de MySQL
Puede conectarse desde la línea de comando a una instancia de base de datos de Amazon RDScon AWS CLI y la herramienta de línea de comandos de `mysql` como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al de instancia de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**nota**
Para obtener información sobre cómo conectarse a la base de datos mediante SQL Workbench/J con la autenticación IAM, consulte la publicación de blog [Use IAM authentication to connect with SQL Workbench/J to Aurora MySQL or Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/).
**Topics**
+ [
## Generación de un token de autenticación de IAM
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [
## Conexión a su instancia
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)
## Generación de un token de autenticación de IAM
En el siguiente ejemplo se muestra cómo obtener un token de autenticación firmado mediante la 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
```
En el ejemplo, los parámetros son los siguientes:
+ `--hostname`: el nombre de host de la instancia a los que desea obtener acceso.
+ `--port`: el número de puerto que se utiliza para conectarse a la instancia.
+ `--region`: la región de AWS en la que se ejecuta la instancia
+ `--username`: la cuenta de base de datos a la que desea acceder.
Los primeros caracteres del token tienen un aspecto similar al siguiente.
```
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**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión de la instancia de base de datos para generar el token de autenticación.
## Conexión a su instancia
El formato general para conectarse se muestra a continuación.
```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```
Los parámetros son los siguientes:
+ `--host`: el nombre de host de la instancia a los que desea obtener acceso.
+ `--port`: el número de puerto que se utiliza para conectarse a la instancia.
+ `--ssl-ca`: la ruta completa al archivo de certificado SSL que contiene la clave pública
Para obtener más información sobre la compatibilidad con SSL/TLS para MariaDB, consulte [Compatibilidad con SSL/TLS para instancias de base de datos de MariaDB en Amazon RDS](MariaDB.Concepts.SSLSupport.md).
Para obtener más información sobre la compatibilidad con SSL/TLS para MySQL, consulte [Compatibilidad de SSL/TLS con instancias de bases de datos de MySQL en Amazon RDS](MySQL.Concepts.SSLSupport.md).
Para descargar un certificado SSL, consulte [Uso de SSL/TLS para cifrar una conexión a una instancia o un clúster de base de datos](UsingWithRDS.SSL.md).
+ `--enable-cleartext-plugin`: un valor que especifica que `AWSAuthenticationPlugin` debe usarse para esta conexión.
Si está utilizando un cliente MariaDB, la opción `--enable-cleartext-plugin` no es necesaria.
+ `--user`: la cuenta de base de datos a la que desea acceder.
+ `--password`: un token de autenticación de IAM firmado.
El token de autenticación consta de varios cientos de caracteres. Puede ser difícil de tratar en la línea de comando. Una forma de solucionar esto es guardar el token en una variable de entorno y, a continuación, usar esa variable al conectarse. En el siguiente ejemplo se muestra una forma de realizar esta alternativa. En el ejemplo, */sample\$1dir/* es la ruta completa al archivo de certificado SSL que contiene la clave 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
```
Al conectarse mediante `AWSAuthenticationPlugin`, la conexión está protegida mediante SSL. Para verificar esto, escriba lo siguiente en el símbolo del sistema `mysql>`.
```
show status like 'Ssl%';
```
En las siguientes líneas de la salida aparecen más detalles.
```
+---------------+-------------+
| Variable_name | Value |
+---------------+-------------+
| ... | ...
| Ssl_cipher | AES256-SHA |
| ... | ...
| Ssl_version | TLSv1.1 |
| ... | ...
+-----------------------------+
```
Si desea conectarse a una instancia de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión a su instancia desde la línea de comandos: AWS CLI y psql Client
Puede conectarse desde la línea de comando a una instancia de base de datos de Amazon RDS para PostgreSQL con AWS CLI y la herramienta de línea de comandos psql como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al de instancia de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**nota**
Para obtener información acerca de cómo conectarse a la base de datos mediante pgAdmin con la autenticación IAM, consulte la entrada de blog [Use IAM authentication to connect with pgAdmin to Amazon Aurora PostgreSQL or Amazon RDS for PostgreSQL (Usar la autenticación de IAM para conectarse con pgAdmin a Amazon Aurora PostgreSQL o Amazon RDS for PostgreSQL)](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/).
**Topics**
+ [
## Generación de un token de autenticación de IAM
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [
## Conexión a una instancia de base de datos de PostgreSQL en Amazon RDS
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)
## Generación de un token de autenticación de IAM
El token de autenticación consta de varios cientos de caracteres por que puede ser difícil de tratar en la línea de comando. Una forma de solucionar esto es guardar el token en una variable de entorno y, a continuación, usar esa variable al conectarse. En el siguiente ejemplo se muestra cómo usar la AWS CLI para obtener un token de autenticación firmado mediante el comando `generate-db-auth-token` y almacenarlo en una variable de entorno `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 )"
```
En el ejemplo, los parámetros para el comando `generate-db-auth-token` son los siguientes:
+ `--hostname`: el nombre de host de la instancia de base de datos a los que desea obtener acceso.
+ `--port`: el número de puerto que se utiliza para conectarse a la instancia.
+ `--region`: la región de AWS en la que se ejecuta la instancia
+ `--username`: la cuenta de base de datos a la que desea acceder.
Los primeros caracteres del token generado tienen un aspecto similar al siguiente.
```
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**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión de la instancia de base de datos para generar el token de autenticación.
## Conexión a una instancia de base de datos de PostgreSQL en Amazon RDS
El formato general para usar psql para conectarse se muestra a continuación.
```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```
Los parámetros son los siguientes:
+ `host`: el nombre de host de la instancia de base de datos a los que desea obtener acceso.
+ `port`: el número de puerto que se utiliza para conectarse a la instancia.
+ `sslmode`: el modo de SSL que se debe utilizar.
Cuando se utiliza `sslmode=verify-full`, la conexión SSL verifica el punto de conexión de la instancia con respecto al punto de enlace del certificado SSL.
+ `sslrootcert`: la ruta completa al archivo de certificado SSL que contiene la clave pública
Para obtener más información, consulte [Uso de SSL con una instancia de base de datos PostgreSQL](PostgreSQL.Concepts.General.SSL.md).
Para descargar un certificado SSL, consulte [Uso de SSL/TLS para cifrar una conexión a una instancia o un clúster de base de datos](UsingWithRDS.SSL.md).
+ `dbname`: la base de datos a la que desea obtener acceso.
+ `user`: la cuenta de base de datos a la que desea acceder.
+ `password`: un token de autenticación de IAM firmado.
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión de la instancia de base de datos para generar el token de autenticación.
El siguiente ejemplo muestra el uso de psql para conectarse. En el ejemplo, psql utiliza la variable de entorno `RDSHOST` para el host y la variable de entorno `PGPASSWORD` para el token generado. Además, */sample\$1dir/* es la ruta completa al archivo de certificado SSL que contiene la clave 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"
```
Si desea conectarse a una instancia de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión la instancia de base de datos mediante la autenticación de IAM y el AWS SDK para .NET
Puede conectarse a una instancia de base de datos de RDS for MariaDB, MySQL o PostgreSQL con el AWS SDK para .NET como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al de instancia de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Ejemplos**
En los siguientes ejemplos de código, se muestra cómo se genera un token de autenticación y cómo se utiliza para conectarse a una instancia.
Para ejecutar este ejemplo de código, necesita [AWS SDK para .NET](https://aws.amazon.com/sdk-for-net/), que se encuentra en el sitio de AWS. Los paquetes `AWSSDK.CORE` y `AWSSDK.RDS` son necesarios. Para conectarse a una instancia de base de datos, use el conector de base de datos .NET para el motor de base de datos, como MySqlConnector para MariaDB o MySQL, o Npgsql para PostgreSQL.
Este código se conecta a una instancia de base de datos de MariaDB o MySQL. Modifique los valores de las siguientes variables según sea necesario:
+ `server`: el punto de enlace de la instancia que desea acceder
+ `user`: la cuenta de base de datos a la que desea acceder.
+ `database`: la base de datos a la que desea obtener acceso.
+ `port`: el número de puerto que se utiliza para conectarse a la instancia.
+ `SslMode`: el modo de SSL que se debe utilizar.
Cuando se utiliza `SslMode=Required`, la conexión SSL verifica el punto de conexión de la instancia con respecto al punto de enlace del certificado SSL.
+ `SslCa`: la ruta completa al certificado SSL de Amazon RDS
Para descargar un certificado, consulte [Uso de SSL/TLS para cifrar una conexión a una instancia o un clúster de base de datos](UsingWithRDS.SSL.md).
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión de la instancia de base de datos para generar el token de autenticación.
```
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();
}
}
}
```
Este código se conecta a una instancia de base de datos de PostgreSQL.
Modifique los valores de las siguientes variables según sea necesario:
+ `Server`: el punto de enlace de la instancia que desea acceder
+ `User ID`: la cuenta de base de datos a la que desea acceder.
+ `Database`: la base de datos a la que desea obtener acceso.
+ `Port`: el número de puerto que se utiliza para conectarse a la instancia.
+ `SSL Mode`: el modo de SSL que se debe utilizar.
Cuando se utiliza `SSL Mode=Required`, la conexión SSL verifica el punto de conexión de la instancia con respecto al punto de enlace del certificado SSL.
+ `Root Certificate`: la ruta completa al certificado SSL de Amazon RDS
Para descargar un certificado, consulte [Uso de SSL/TLS para cifrar una conexión a una instancia o un clúster de base de datos](UsingWithRDS.SSL.md).
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión de la instancia de base de datos para generar el token de autenticación.
```
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();
}
}
}
```
Si desea conectarse a una instancia de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión la instancia de base de datos mediante la autenticación de IAM y el AWS SDK para Go
Puede conectarse a una instancia de base de datos de RDS for MariaDB, MySQL o PostgreSQL con el AWS SDK para Go como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al de instancia de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Ejemplos**
Para ejecutar estos ejemplos de código, necesita [AWS SDK para Go](https://aws.amazon.com/sdk-for-go/), que se encuentra en el sitio de AWS.
Modifique los valores de las siguientes variables según sea necesario:
+ `dbName`: la base de datos a la que desea obtener acceso.
+ `dbUser`: la cuenta de base de datos a la que desea acceder.
+ `dbHost`: el punto de enlace de la instancia que desea acceder
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión de la instancia de base de datos para generar el token de autenticación.
+ `dbPort`: el número de puerto que se utiliza para conectarse a la instancia.
+ `region`: la región de AWS en la que se ejecuta la instancia
Además, debe asegurarse de que las bibliotecas importadas en el código de muestra existen en el sistema.
**importante**
En los ejemplos de esta sección se utiliza el código siguiente para proporcionar credenciales que tienen acceso a una base de datos desde un entorno local:
`creds := credentials.NewEnvCredentials()`
Si accede a una base de datos desde un servicio de AWS, como Amazon EC2 o Amazon ECS, puede reemplazar el código por el siguiente código:
`sess := session.Must(session.NewSession())`
`creds := sess.Config.Credentials`
Si realiza este cambio, asegúrese de agregar la siguiente importación:
`"github.com/aws/aws-sdk-go/aws/session"`
**Topics**
+ [
## Conexión mediante la autenticación de IAM y el V2 AWS SDK para Go
](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [
## Conexión mediante la autenticación de IAM y el V1 AWS SDK para Go
](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)
## Conexión mediante la autenticación de IAM y el V2 AWS SDK para Go
Se puede conectar a unclúster de base de datos mediante la autenticación de IAM y el V2AWS SDK para Go.
En los siguientes ejemplos de código, se muestra cómo se genera un token de autenticación y cómo se utiliza para conectarse a una instancia.
Este código se conecta a una instancia de base de datos de MariaDB o 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)
}
}
```
Este código se conecta a una instancia de base de datos de 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)
}
}
```
Si desea conectarse a una instancia de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
## Conexión mediante la autenticación de IAM y el V1 AWS SDK para Go
Conexión a una instancia mediante la autenticación de IAM y el V1 AWS SDK para Go
En los siguientes ejemplos de código, se muestra cómo se genera un token de autenticación y cómo se utiliza para conectarse a una instancia.
Este código se conecta a una instancia de base de datos de MariaDB o 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)
}
}
```
Este código se conecta a una instancia de base de datos de 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)
}
}
```
Si desea conectarse a una instancia de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión la instancia de base de datos mediante la autenticación de IAM y el AWS SDK para Java
Puede conectarse a una instancia de base de datos de RDS for MariaDB, MySQL o PostgreSQL con el AWS SDK para Java como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al de instancia de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Configurar el SDK de AWS para Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
Para ver ejemplos de cómo usar el SDK para Java 2.x, consulte [Ejemplos de Amazon RDS que utilizan SDK para Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html). También puede utilizar el contenedor JDBC avanzado de AWS; consulte la [documentación del contenedor JDBC avanzado de AWS](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md).
**Topics**
+ [
## Generación de un token de autenticación de IAM
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [
## Creación manual de un token de autenticación de IAM
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [
## Conexión a su instancia
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)
## Generación de un token de autenticación de IAM
Si escribe programas mediante AWS SDK para Java, puede obtener un token de autenticación firmado mediante la clase `RdsIamAuthTokenGenerator`. El uso de esta clase requiere que proporcione las credenciales de AWS. Para hacer esto, puede crear una instancia de la clase `DefaultAWSCredentialsProviderChain`. `DefaultAWSCredentialsProviderChain` usa la primera clave de acceso y clave secreta de AWS que encuentra en la [cadena predeterminada de proveedores de credenciales](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default). A fin de obtener más información acerca de las claves de acceso de AWS, consulte [Administración de claves de acceso para usuarios](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión de la instancia de base de datos para generar el token de autenticación.
Tras crear una instancia de `RdsIamAuthTokenGenerator`, puede llamar al método `getAuthToken` para obtener un token firmado. Proporcione la región de AWS el nombre de host, el número de puerto y el nombre de usuario. En el siguiente ejemplo de código se ilustra cómo hacerlo.
```
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;
}
}
```
## Creación manual de un token de autenticación de IAM
En Java, la forma más sencilla de generar un token de autenticación es usar `RdsIamAuthTokenGenerator`. Esta clase crea automáticamente un token de autenticación y, a continuación, lo firma mediante AWS Signature versión 4. Para obtener más información, consulte [Proceso de firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) en la *Referencia general de AWS*.
Sin embargo, también puede crear y firmar un token de autenticación manualmente, como se muestra en el siguiente ejemplo de código.
```
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);
}
}
}
```
## Conexión a su instancia
El siguiente ejemplo de código, muestra cómo generar un token de autenticación y, a continuación, usarlo para conectarse a una instancia que ejecuta MariaDB o MySQL.
Para ejecutar este ejemplo de código, necesita [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/), que se encuentra en el sitio de AWS. Además, necesitará lo siguiente:
+ MySQL Connector/J. Este ejemplo de código se ha probado con `mysql-connector-java-5.1.33-bin.jar`.
+ Un certificado intermedio para Amazon RDS que es específico de una región de AWS. (Para obtener más información, consulte [Uso de SSL/TLS para cifrar una conexión a una instancia o un clúster de base de datos](UsingWithRDS.SSL.md).) En tiempo de ejecución, el cargador de clases busca el certificado en el mismo directorio que este ejemplo de código Java, de modo que el cargador de clases pueda encontrarlo.
+ Modifique los valores de las siguientes variables según sea necesario:
+ `RDS_INSTANCE_HOSTNAME`: el nombre de anfitrión de la instancia que desea acceder.
+ `RDS_INSTANCE_PORT`: el número de puerto usado para conectarse a la instancia de PostgreSQL.
+ `REGION_NAME`: la región de AWS en la que se ejecuta la instancia.
+ `DB_USER`: la cuenta de base de datos a la que desea acceder.
+ `SSL_CERTIFICATE`: un certificado de SSL para Amazon RDS que es específico de una región de AWS.
Para descargar un certificado para su región de AWS, consulte [Uso de SSL/TLS para cifrar una conexión a una instancia o un clúster de base de datos](UsingWithRDS.SSL.md). Coloque el certificado SSL en el mismo directorio que este archivo de programa Java, de modo que el cargador de clases pueda encontrar el certificado en tiempo de ejecución.
En este ejemplo de código, se obtienen las credenciales de AWS de la [cadena predeterminada de proveedores de credenciales](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default).
**nota**
Especifique una contraseña para `DEFAULT_KEY_STORE_PASSWORD` que no sea la que se muestra aquí como práctica recomendada de seguridad.
```
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");
}
}
```
Si desea conectarse a una instancia de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión la instancia de base de datos mediante la autenticación de IAM y el AWS SDK para Python (Boto3)
Puede conectarse a una instancia de base de datos de RDS for MariaDB, MySQL o PostgreSQL con el AWS SDK para Python (Boto3) como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al de instancia de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
Además, debe asegurarse de que las bibliotecas importadas en el código de muestra existen en el sistema.
**Ejemplos**
Los ejemplos de código utilizan perfiles para credenciales compartidas. Para obtener información acerca de la especificación de credenciales, consulte [Credenciales](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) en la documentación de AWS SDK para Python (Boto3).
En los siguientes ejemplos de código, se muestra cómo se genera un token de autenticación y cómo se utiliza para conectarse a una instancia.
Para ejecutar este ejemplo de código, necesita [AWS SDK para Python (Boto3)](https://aws.amazon.com/sdk-for-python/), que se encuentra en el sitio de AWS.
Modifique los valores de las siguientes variables según sea necesario:
+ `ENDPOINT`: el punto de enlace de la instancia que desea acceder
+ `PORT`: el número de puerto que se utiliza para conectarse a la instancia.
+ `USER`: la cuenta de base de datos a la que desea acceder.
+ `REGION`: la región de AWS en la que se ejecuta la instancia
+ `DBNAME`: la base de datos a la que desea obtener acceso.
+ `SSLCERTIFICATE`: la ruta completa al certificado SSL de Amazon RDS
Para `ssl_ca`, especifique un certificado SSL. Para descargar un certificado SSL, consulte [Uso de SSL/TLS para cifrar una conexión a una instancia o un clúster de base de datos](UsingWithRDS.SSL.md).
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión de la instancia de base de datos para generar el token de autenticación.
Este código se conecta a una instancia de base de datos de MariaDB o MySQL.
Antes de ejecutar este código, siga las instrucciones del [índice del paquete de Python](https://pypi.org/project/PyMySQL/) para instalar el controlador 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))
```
Este código se conecta a una instancia de base de datos de PostgreSQL.
Antes de ejecutar este código, instale `psycopg2` y siga las instrucciones en [Psycopg documentation](https://pypi.org/project/psycopg2/) (Documentación de Psycopg).
```
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))
```
Si desea conectarse a una instancia de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Solución de problemas de autenticación de bases de datos de IAM
A continuación, encontrará ideas para la solución de problemas comunes de autenticación de bases de datos de IAM e información sobre los registros y métricas de CloudWatch para la autenticación de base de datos de IAM.
## Exportación de registros de errores de autenticación de bases de datos de IAM a Registros de CloudWatch
Los registros de errores de autenticación de bases de datos de IAM se almacenan en el host de base de datos y puede exportar estos registros a la cuenta de Registros de CloudWatch. Utilice los registros y métodos de solución de esta página para solucionar los problemas de autenticación de bases de datos de IAM.
Puede habilitar la exportación de registros a Registros de CloudWatch desde la consola, la AWS CLI y la API de RDS. Para obtener instrucciones sobre la consola, consulte [Publicación de registros de base de datos en registros de Amazon Cloudwatch](USER_LogAccess.Procedural.UploadtoCloudWatch.md).
Para exportar los registros de errores de autenticación de bases de datos de IAM a Registros de CloudWatch al crear una instancia de base de datos desde la AWS CLI, utilice el siguiente 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 los registros de errores de autenticación de bases de datos de IAM a Registros de CloudWatch al modificar una instancia de base de datos desde la AWS CLI, utilice el siguiente 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 si la instancia de base de datos está exportando los registros de autenticación de base de datos de IAM a Registros de CloudWatch, compruebe si el parámetro `EnabledCloudwatchLogsExports` está establecido en `iam-db-auth-error` en la salida del comando `describe-db-instances`.
```
aws rds describe-db-instances --region us-east-1 --db-instance-identifier mydbinstance
...
"EnabledCloudwatchLogsExports": [
"iam-db-auth-error"
],
...
```
## Métricas de CloudWatch de autenticación de bases de datos de IAM
Amazon RDS proporciona métricas casi en tiempo real sobre la autenticación de bases de datos de IAM a la cuenta de Amazon CloudWatch. En la siguiente tabla se enumeran las métricas de autenticación de bases de datos de IAM disponibles mediante CloudWatch:
| Métrica | Descripción |
| --- | --- |
| `IamDbAuthConnectionRequests` | Número total de solicitudes de conexión realizadas con autenticación de bases de datos de IAM. |
| `IamDbAuthConnectionSuccess` | Número total de solicitudes de autenticación de bases de datos de IAM correctamente realizadas. |
| `IamDbAuthConnectionFailure` | Número total de solicitudes de autenticación de bases de datos de IAM con error. |
| `IamDbAuthConnectionFailureInvalidToken` | Número total de solicitudes de autenticación de bases de datos de IAM con error debido a un token no válido. |
| `IamDbAuthConnectionFailureInsufficientPermissions` | Número total de solicitudes de autenticación de bases de datos de IAM con error debido a políticas o permisos incorrectos. |
| `IamDbAuthConnectionFailureThrottling` | Número total de solicitudes de autenticación de bases de datos de IAM con error debido a la limitación de la autenticación de bases de datos de IAM. |
| `IamDbAuthConnectionFailureServerError` | Número total de solicitudes de autenticación de bases de datos de IAM con error debido a un error interno del servidor en la característica de autenticación de bases de datos de IAM. |
## Problemas y soluciones comunes de
Es posible que se encuentre con los siguientes problemas al utilizar la autenticación de bases de datos de IAM. Utilice los pasos de corrección de la tabla para resolver los problemas:
| Error | Métricas | Causa | Solución |
| --- | --- | --- | --- |
| `[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` | El token de autenticación de bases de datos de IAM en la solicitud de conexión no es un token SigV4a válido o no tiene el formato correcto. | Compruebe la estrategia de generación de tokens en la aplicación. En algunos casos, asegúrese de que pasa el token con un formato válido. Si se trunca el token (o se aplica un formato de cadena incorrecto), el token no será vá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` | El token de autenticación de bases de datos de IAM ha caducado. Los tokens solo son válidos durante 15 minutos. | Compruebe la lógica de almacenamiento en caché de tokens o de reutilización de tokens en la aplicación. No debe reutilizar tokens que tengan más 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` | Este error es posible que se deba a las siguientes razones: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.Troubleshooting.html) | Verifique el rol o la política de IAM que está asumiendo en la aplicación. Asegúrese de que asume la misma política para generar el token que para conectarse a la base de datos. |
| `[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` | Está realizando demasiadas solicitudes de conexión a la base de datos en un corto período de tiempo. El límite de limitación de autenticación de bases de datos de IAM es de 200 conexiones por segundo. | Reduzca la velocidad de establecimiento de nuevas conexiones con la autenticación de IAM. Considere implementar la agrupación de conexiones mediante Proxy de RDS para reutilizar las conexiones establecidas en la aplicación. |
| `[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` | Se ha producido un error interno al autorizar la conexión de la base de datos con la autenticación de bases de datos de IAM. | Póngase en contacto con https://aws.amazon.com/premiumsupport/ para investigar el problema. |
# Solución de problemas de identidades y accesos en Amazon RDS
Utilice la información siguiente para diagnosticar y solucionar los problemas comunes que puedan surgir cuando trabaje con Amazon RDS e IAM.
**Topics**
+ [
## No tengo autorización para realizar una acción en Amazon RDS
](#security_iam_troubleshoot-no-permissions)
+ [
## No estoy autorizado a realizar la operación iam:PassRole
](#security_iam_troubleshoot-passrole)
+ [
## Quiero permitir que personas ajenas a mi cuenta de AWS accedan a mis recursos de Amazon RDS.
](#security_iam_troubleshoot-cross-account-access)
## No tengo autorización para realizar una acción en Amazon RDS
Si la Consola de administración de AWS le indica que no está autorizado para llevar a cabo una acción, debe ponerse en contacto con su gestionador para recibir ayuda. El gestionador es la persona que le proporcionó las credenciales de inicio de sesión.
En el siguiente ejemplo, el error se produce cuando el usuario `mateojackson`, intenta utilizar la consola para ver detalles sobre un *widget*, pero no tiene permisos `rds:GetWidget`.
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: rds:GetWidget on resource: my-example-widget
```
En este caso, Mateo pide a su administrador que actualice sus políticas de forma que pueda obtener acceso al recurso `my-example-widget` mediante la acción `rds:GetWidget`.
## No estoy autorizado a realizar la operación iam:PassRole
Si recibe un error que indica que no está autorizado para llevar a cabo la acción `iam:PassRole`, debe ponerse en contacto con su administrador para recibir ayuda. El administrador es la persona que le proporcionó las credenciales de inicio de sesión. Pida a la persona que actualice sus políticas de forma que pueda transferir un rol a Amazon RDS.
Algunos servicios de AWS le permiten transferir un rol existente a dicho servicio en lugar de crear un nuevo rol de servicio o uno vinculado al servicio. Para ello, debe tener permisos para transferir el rol al servicio.
En el siguiente ejemplo, el error se produce cuando un usuario denominado `marymajor` intenta utilizar la consola para realizar una acción en Amazon RDS. Sin embargo, la acción requiere que el servicio cuente con permisos otorgados por un rol de servicio. Mary no tiene permisos para transferir el rol al servicio.
```
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
```
En este caso, Mary pide a su administrador que actualice sus políticas de forma que pueda realizar la acción `iam:PassRole`.
## Quiero permitir que personas ajenas a mi cuenta de AWS accedan a mis recursos de Amazon RDS.
Se puede crear un rol que los usuarios de otras cuentas o las personas externas a la organización puedan utilizar para acceder a sus recursos. Se puede especificar una persona de confianza para que asuma el rol. En el caso de los servicios que admitan las políticas basadas en recursos o las listas de control de acceso (ACL), puede utilizar dichas políticas para conceder a las personas acceso a sus recursos.
Para obtener más información, consulte lo siguiente:
+ Para obtener información acerca de si Amazon RDS admite estas características, consulte [Cómo funciona Amazon RDS con IAM](security_iam_service-with-iam.md).
+ Para obtener información acerca de cómo proporcionar acceso a los recursos de las cuentas de AWS de su propiedad, consulte [Proporcionar acceso a un usuario de IAM a otra cuenta de AWS de la que es propietario](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) en la *Guía del usuario de IAM*.
+ Para obtener información acerca de cómo proporcionar acceso a los recursos a cuentas de AWS de terceros, consulte [Proporcionar acceso a cuentas de AWS que son propiedad de terceros](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html) en la *Guía del usuario de IAM*.
+ Para obtener información sobe cómo proporcionar acceso mediante una identidad federada, consulte [Proporcionar acceso a usuarios autenticados externamente (identidad federada)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) en la *Guía del usuario de IAM*.
+ Para obtener información sobre la diferencia entre los roles y las políticas basadas en recursos para el acceso entre cuentas, consulte [Cómo los roles de IAM difieren de las políticas basadas en recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html) en la *Guía del usuario de IAM*.