# Roles de IAM
<a name="id_roles"></a>

Un *rol* de IAM es una identidad de IAM que puede crear en su cuenta y que tiene permisos específicos. Un rol de IAM es similar a un usuario de IAM en que se trata de una identidad de AWS con políticas de permisos que determinan lo que la identidad puede hacer y lo que no en AWS. No obstante, en lugar de asociarse exclusivamente a una persona, la intención es que cualquier usuario pueda asumir un rol que necesite. Además, un rol no tiene asociadas credenciales a largo plazo estándar, como una contraseña o claves de acceso. En su lugar, cuando se asume un rol, este proporciona credenciales de seguridad temporales para la sesión de rol.

Puede utilizar roles para delegar el acceso a usuarios, aplicaciones o servicios que normalmente no tendrían acceso a los recursos de AWS. Por ejemplo, es posible que desee conceder a los usuarios de la cuenta de AWS el acceso a los recursos que no suelen tener, o conceder a los usuarios de una Cuenta de AWS el acceso a los recursos de otra cuenta. O es posible que quiera permitir que una aplicación móvil utilice los recursos de AWS, pero no desea integrar las claves de AWS dentro la aplicación (donde puede ser difícil actualizarlas y donde es posible que los usuarios las extraigan). En ocasiones, es posible que quiera conceder acceso a AWS a los usuarios que ya tienen identidades definidas fuera de AWS, como en su directorio corporativo. O bien, es posible que quiera conceder acceso a su cuenta a terceros para que puedan realizar una auditoría en los recursos.

En estas situaciones, puede delegar el acceso a los recursos de AWS con un *rol de IAM*. En esta sección se presentan los roles y las distintas formas de utilizarlos, cuándo y cómo elegir entre enfoques y cómo crear, administrar, cambiar (o asumir) y eliminar roles.

**nota**  
Cuando crea su Cuenta de AWS por primera vez, no se crea ningún rol de forma predeterminada. A medida que agregue servicios a su cuenta, es posible que agreguen roles vinculados a servicios para respaldar sus casos de uso.  
 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.   
Antes de eliminar los roles vinculados a servicios, debe borrar sus recursos relacionados. De esta forma, se protegen los recursos, ya que se evita que se puedan eliminar accidentalmente permisos de acceso a los recursos.  
Para obtener información sobre los servicios que admiten el uso de roles vinculados a servicios, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md) y busque los servicios que tengan **Yes **en la columna **Service-Linked Role**. Elija una opción **Sí** con un enlace para ver la documentación acerca del rol vinculado al servicio en cuestión.

**Topics**
+ [

## Cuándo crear un usuario de IAM (en lugar de un rol)
](#id_which-to-choose)
+ [

## Términos y conceptos de roles
](#id_roles_terms-and-concepts)
+ [

## Recursos adicionales
](#id_roles_additional-resources)
+ [

# El problema del suplente confuso
](confused-deputy.md)
+ [

# Escenarios habituales en los roles de IAM
](id_roles_common-scenarios.md)
+ [

# Creación de roles de IAM
](id_roles_create.md)
+ [

# Administración de roles de IAM
](id_roles_manage.md)
+ [

# Métodos para asumir un rol
](id_roles_manage-assume.md)

## Cuándo crear un usuario de IAM (en lugar de un rol)
<a name="id_which-to-choose"></a>

Se recomienda usar usuarios de IAM únicamente para casos de uso que no sean compatibles con la federación de identidades. Estos son algunos de los casos de uso:
+ **Cargas de trabajo que no pueden utilizar roles de IAM**: puede ejecutar una carga de trabajo desde una ubicación que necesite acceder a AWS. En algunas situaciones, no se pueden utilizar roles de IAM para proporcionar credenciales temporales; por ejemplo, en el caso de los complementos de WordPress. En esas situaciones, utilice claves de acceso a largo plazo de usuarios de IAM para que la carga de trabajo se autentique en AWS.
+ **Clientes de externos de AWS**: si utiliza herramientas que no admiten el acceso con IAM Identity Center, como clientes externos de AWS o proveedores que no están alojados en AWS, utilice claves de acceso a largo plazo de usuarios de IAM.
+ **Acceso a AWS CodeCommit**: si utiliza CodeCommit para almacenar el código, puede emplea un usuario de IAM con claves SSH o credenciales específicas del servicio para que CodeCommit se autentique en los repositorios. Se recomienda hacer esto además de utilizar un usuario de IAM Identity Center para la autenticación normal. Los usuarios de IAM Identity Center son el personal que necesita acceso a sus Cuentas de AWS o a sus aplicaciones en la nube. Para dar acceso a los usuarios a los repositorios de CodeCommit sin configurar usuarios de IAM, puede configurar la utilidad **git-remote-codecommit**. Para obtener más información sobre IAM y CodeCommit, consulte [Credenciales de IAM para CodeCommit: credenciales Git, claves SSH y claves de acceso de AWS](id_credentials_ssh-keys.md). Para obtener más información sobre cómo configurar la utilidad **git-remote-codecommit**, consulte [Conexión a repositorios de AWS CodeCommit con credenciales rotativas](https://docs.aws.amazon.com/codecommit/latest/userguide/temporary-access.html#temporary-access-configure-credentials) en la *Guía del usuario de AWS CodeCommit*.
+ **Acceso a Amazon Keyspaces (para Apache Cassandra)**: en una situación en la que no pueda utilizar usuarios de IAM Identity Center, como por ejemplo, para probar la compatibilidad con Cassandra, puede utilizar un usuario de IAM con credenciales específicas del servicio para realizar la autenticación en Amazon Keyspaces. Los usuarios de IAM Identity Center son el personal que necesita acceso a sus Cuentas de AWS o a sus aplicaciones en la nube. También puede conectarse a Amazon Keyspaces con credenciales temporales. Para obtener más información, consulte [Uso de credenciales temporales para conectarse a Amazon Keyspaces mediante un rol de IAM y el complemento SigV4](https://docs.aws.amazon.com/keyspaces/latest/devguide/access.credentials.html#temporary.credentials.IAM) en la *Guía para desarrolladores de Amazon Keyspaces (para Apache Cassandra)*.
+ **Acceso de emergencia**: en caso de que no pueda acceder a su proveedor de identidad y deba realizar alguna acción en su Cuenta de AWS. Puede establecer usuarios de IAM de acceso de emergencia como parte de su plan de resiliencia. Recomendamos que las credenciales de usuario de emergencia estén estrictamente controladas y protegidas mediante autenticación multifactor (MFA).

## Términos y conceptos de roles
<a name="id_roles_terms-and-concepts"></a>

A continuación se muestran algunos términos básicos para ayudarle a comenzar con el uso de los roles.

****Rol****  
Una identidad de IAM que se puede crear en una cuenta y que tiene permisos específicos. Un rol de IAM tiene algunas similitudes con un usuario de IAM. Los roles y los usuarios son identidades de AWS con políticas de permisos que determinan lo que la identidad puede y no puede hacer en AWS. No obstante, en lugar de asociarse exclusivamente a una persona, la intención es que cualquier usuario pueda asumir un rol que necesite. Además, un rol no tiene asociadas credenciales a largo plazo estándar, como una contraseña o claves de acceso. En su lugar, cuando se asume un rol, este proporciona credenciales de seguridad temporales para la sesión de rol.  
Las siguientes opciones pueden utilizar los roles:  
+ Un usuario de IAM en la misma Cuenta de AWS o en otra Cuenta de AWS
+ Roles de IAM en la misma cuenta
+ Entidades principales de servicio, para su uso con servicios de AWS y características como:
  + Servicios que permiten ejecutar código en servicios de computación, como Amazon EC2 o AWS Lambda
  + Características que realizan acciones en sus recursos en su nombre, como la replicación de objetos en Amazon S3
  + Servicios que proporcionan credenciales de seguridad temporales a sus aplicaciones que se ejecutan fuera de AWS, como IAM Roles Anywhere o Amazon ECS Anywhere
+ Un usuario externo autenticado por un servicio de proveedor de identidades (IdP) externo que sea compatible con SAML 2.0 u OpenID Connect

****AWS Rol de servicio****  
 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*. 

****AWS Rol vinculado al servicio de****  
 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.   
Si ya está utilizando un servicio cuando comienza a admitir roles vinculados a servicios, es posible que reciba un mensaje de correo electrónico anunciándole la adición de un nuevo rol en su cuenta. En este caso, el servicio crea automáticamente el rol vinculado a sí mismo en su cuenta. No es necesario realizar ninguna acción para admitir este rol y no debe eliminarlo manualmente. Para obtener más información, consulte [Un nuevo rol ha aparecido en la cuenta de AWS](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared).
Para obtener información sobre los servicios que admiten el uso de roles vinculados a servicios, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md) y busque los servicios que tengan **Yes **en la columna **Service-Linked Role**. Elija una opción **Sí** con un enlace para ver la documentación acerca del rol vinculado al servicio en cuestión. Para obtener más información, consulte [Creación de un rol vinculado al servicio](id_roles_create-service-linked-role.md).

****Encadenamiento de roles****  
El encadenamiento de roles se produce cuando se utiliza un rol para asumir un segundo rol. Esto puede realizarse a través de la Consola de administración de AWS cuando se cambian los roles, la AWS CLI o la API. Por ejemplo, `RoleA` tiene permiso para asumir `RoleB`. Puede permitir a User1 que asuma el `RoleA` al utilizar las credenciales de usuario a largo plazo en la operación de la API AssumeRole. Esto devuelve las credenciales a corto plazo de `RoleA`. Para utilizar el encadenamiento de roles, puede emplear las credenciales a corto plazo de `RoleA` para permitir a User1 que asuma el `RoleB`.  
Cuando asume un rol, puede pasar una etiqueta de sesión y establecer la etiqueta como transitiva. Las etiquetas de sesión transitivas se pasan a todas las sesiones posteriores de una cadena de roles. Para obtener más información sobre las etiquetas de sesión, consulte [Transferencia de etiquetas de sesión en AWS STS](id_session-tags.md).  
El encadenamiento de roles limita la Consola de administración de AWS, la AWS CLI o la sesión de rol de la API de AWS a un máximo de una hora. Se aplica sin importar la duración máxima de sesión establecida para cada uno de los roles. Cuando utilice la operación API [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) para asumir un rol, puede especificar la duración de la sesión de su rol con el parámetro `DurationSeconds`. Puede especificar un valor de parámetro de hasta 43200 segundos (12 horas), en función del [valor de la duración máxima de la sesión](id_roles_update-role-settings.md#id_roles_update-session-duration) del rol. Sin embargo, si se asume un rol mediante el encadenamiento de roles y se proporciona un valor para el parámetro `DurationSeconds` superior a una hora, la operación produce un error.  
Para obtener más información acerca del cambio de rol en la Consola de administración de AWS, consulte [Cambiar de usuario a rol de IAM (consola)](id_roles_use_switch-role-console.md).

****Delegación****  
Es la concesión de permisos a alguien para que obtenga acceso a los recursos que estén bajo su control. La delegación implica establecer una relación de confianza entre dos cuentas. La primera es la cuenta que posee el recurso (la cuenta que confía). El segundo es la cuenta que contiene los usuarios que necesitan acceder al recurso (la cuenta de confianza). Las cuentas de confianza y que confía pueden ser cualquiera de las siguientes:  
+ La misma cuenta.
+ Dos cuentas distintas que están bajo el control de la organización.
+ Dos cuentas que son propiedad de diferentes organizaciones.
Para delegar el permiso para obtener acceso a un recurso, [cree un rol de IAM](id_roles_create_for-user.md) en la cuenta que confía que tiene dos políticas asociadas. La *política de permisos* concede al usuario del rol los permisos necesarios para realizar las tareas previstas en el recurso. La *política de confianza* especifica los miembros de la cuenta de confianza que pueden asumir el rol.  
Al crear una política de confianza, no puede especificar un comodín (\$1) como parte de un ARN en la entidad principal. La política de confianza se asocia al rol de la cuenta que confía, y supone la mitad de los permisos. La otra mitad es una política de permisos asociada al usuario de la cuenta de confianza que [permite a dicho usuario cambiar al rol o asumirlo](id_roles_use_permissions-to-switch.md). Un usuario que asume un rol renuncia temporalmente a sus permisos y, en su lugar, asume los permisos del rol. Si el usuario se desconecta o deja de utilizar el rol, los permisos originales del usuario se restablecerán. Un parámetro adicional denominado [ID externo](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id) garantiza el uso seguro de roles entre cuentas no controladas por la misma organización.

****Política de confianza****  
Un [documento de política JSON](reference_policies_grammar.md) en el que se definen las entidades principales en las que *confía* para asumir el rol. Una política de confianza de rol es una [política basada en recursos](access_policies.md#policies_resource-based) requerida que se adjunta a un rol en IAM. [Las entidades principales](reference_policies_elements_principal.md) que puede especificar en la política de confianza incluyen usuarios, roles, cuentas y servicios. Para obtener más información, consulte [“How to use trust policies in IAM roles”](https://aws.amazon.com/blogs//security/how-to-use-trust-policies-with-iam-roles/) en el *Blog de seguridad de AWS*.

****Rol para acceso entre cuentas****  
Un rol que concede acceso a los recursos de una cuenta a una entidad principal de confianza de otra cuenta. Los roles son la forma principal de conceder acceso entre cuentas. Sin embargo, algunos servicios de AWS permiten asociar una política directamente a un recurso (en lugar de utilizar un rol como proxy). Estas se denominan políticas basadas en recursos y puede utilizarlas para conceder a las entidades principales de otra Cuenta de AWS acceso al recurso. Algunos de estos recursos incluyen buckets de Amazon Simple Storage Service (S3), almacenes de Amazon Glacier, temas de Amazon Simple Notification Service (SNS) y colas de Amazon Simple Queue Service (Amazon SQS). Para saber qué servicios admiten políticas basadas en recursos, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md). Para obtener más información sobre las políticas basadas en recursos, consulte [Acceso a recursos entre cuentas en IAM](access_policies-cross-account-resource-access.md).

## Recursos adicionales
<a name="id_roles_additional-resources"></a>

Los siguientes recursos pueden ayudarle a obtener más información sobre la terminología de IAM en relación con las roles de IAM.
+ **Las entidades principales** son entidades de AWS que puede realizar acciones y obtener acceso a los recursos. Una entidad principal puede ser un Usuario raíz de la cuenta de AWS, un usuario de IAM o un rol. Una entidad principal que representa la identidad de un servicio de AWS es un [servicio de entidad principal](reference_policies_elements_principal.md#principal-services). Utilice el elemento de entidad principal en políticas de confianza de rol para definir las entidades principales en las que confía para asumir el rol.

   Para obtener más información y ejemplos de entidades principales a los que puede permitir que asuman un rol, consulte [AWS Elemento de la política de JSON de: Principal](reference_policies_elements_principal.md). 
+ **La federación de identidades** crea una relación de confianza entre un proveedor de identidad externo y AWS. Puede utilizar su proveedor de OpenID Connect (OIDC) o Security Assertion Markup Language (SAML) 2.0 para administrar quién puede acceder a los recursos de AWS. Cuando se utiliza OIDC y SAML 2.0 para configurar una relación de confianza entre estos proveedores de identidad externos y AWS, el usuario se asigna a un rol de IAM. El usuario también recibe credenciales temporales que le permiten tener acceso a los recursos de AWS.

  Para obtener más información sobre las entidades principales federadas, consulte [Proveedores de identidades y federación en AWS](id_roles_providers.md).
+ **Las entidades principales federadas** son identidades existentes de Directory Service, del directorio de usuarios de la empresa o de un proveedor OIDC. AWS asigna un rol a una entidad principal federada cuando se solicita acceso a través de un [proveedor de identidades](id_roles_providers.md).

  Para obtener más información sobre las entidades principales federadas de SAML y OIDC, consulte [Sesiones de usuario federado y roles](introduction_access-management.md#intro-access-roles).
+ **Las políticas de permisos** son políticas basadas en la identidad que definen qué acciones y recursos puede utilizar el rol. El documento se redacta según las reglas del lenguaje de la política de IAM. 

  Para obtener más información, consulte [Referencia de políticas JSON de IAM](reference_policies.md).
+ **Los límites de permisos** son una característica avanzada que permite utilizar políticas para limitar los permisos máximos que una política basada en identidad puede conceder a un rol. No se puede aplicar un límite de permisos a un rol vinculado a un servicio.

  Para obtener más información, consulte [Límites de permisos para las entidades de IAM](access_policies_boundaries.md).

# El problema del suplente confuso
<a name="confused-deputy"></a>

El problema del suplente confuso 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. Para evitarlo, AWS proporciona herramientas que le permiten proteger su cuenta si proporciona acceso a terceros (conocido como *entre cuentas*) u otros servicios de AWS (conocido como *entre servicios*) a los recursos de su cuenta.

A veces, es posible que deba otorgar acceso a terceros a sus recursos de AWS (delegar el acceso). Por ejemplo, supongamos que decide contratar a una empresa externa denominada Example Corp para supervisar su Cuenta de AWS y ayudarlo a optimizar los costos. A fin de realizar un seguimiento de su gasto diario, Example Corp necesita acceder a los recursos de AWS. Example Corp también monitoriza muchas otras cuentas de Cuentas de AWS para otros clientes. Puede utilizar un rol de IAM para establecer una relación de confianza entre su Cuenta de AWS y la cuenta de Example Corp. Un aspecto importante de esta situación es el *ID externo*, un identificador opcional que puede utilizar en una política de confianza del rol de IAM para señalar quién puede asumir el rol. La función principal del ID externo es abordar y prevenir el problema del suplente confuso.

Algunos servicios de AWS (servicios de llamadas) utilizan la entidad principal de su servicio de AWS para acceder a los recursos de AWS de otros servicios de AWS (servicios llamados). En algunas de estas interacciones de servicios, puede configurar los servicios de llamadas para que se comuniquen con los recursos de un servicio llamado en otra Cuenta de AWS. Por ejemplo, la configuración de AWS CloudTrail para escribir en un bucket central de Amazon S3 que se encuentra en otra Cuenta de AWS. Al servicio de llamadas, CloudTrail, se le concede acceso a su bucket S3 según la política del bucket S3 al agregar una declaración de permiso para `cloudtrail.amazonaws.com`.

Cuando la entidad principal de un servicio de llamadas de AWS accede a un recurso de un servicio llamado, la política de recursos del servicio llamado solo autoriza a la entidad principal del servicio de AWS, y no a la persona que configuró el servicio de llamadas. Por ejemplo, un bucket de S3 que confía sin condiciones en la entidad principal del servicio de CloudTrail podría recibir los registros de CloudTrail de las Cuentas de AWS que configure un administrador de confianza, pero también los registros de CloudTrail de una persona no autorizada en su Cuenta de AWS, si conoce el nombre del bucket de S3.

El problema del suplente confuso surge cuando una persona utiliza la confianza de la entidad principal de un servicio de AWS para obtener acceso a recursos a los que no debía tener acceso.

## Prevención del suplente confuso entre cuentas
<a name="mitigate-confused-deputy"></a>

En el diagrama siguiente se muestra el problema del suplente confuso entre cuentas.

![\[Descripción del problema de suplente confuso.\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/confuseddeputyproblem2.png)


Este escenario presupone lo siguiente:
+ **AWS1** es su cuenta de Cuenta de AWS.
+ **AWS1:ExampleRole** es un rol de la cuenta. La política de confianza del rol confía en Example Corp especificando la cuenta de AWS de Example Corp como la que puede asumir el rol.

Y ocurre lo siguiente:

1. Al empezar a utilizar el servicio de Example Corp, usted proporciona el ARN de **AWS1:ExampleRole** a Example Corp.

1. Example Corp utiliza dicho ARN del rol para obtener credenciales de seguridad temporales para acceder a los recursos de la cuenta de Cuenta de AWS. De esta forma, confía en Example Corp como "suplente" que puede actuar en su nombre.

1. Otro cliente de AWS también ha empezado a utilizar los servicios de Example Corp y también ofrece el ARN de **AWS1: ExampleRole** para que lo utilice Example Corp. Probablemente el otro cliente ha averiguado o adivinado el **AWS1:ExampleRole**, que no es un secreto.

1. Cuando el otro cliente solicita a Example Corp obtener acceso a los recursos de AWS en (la que parece ser) su cuenta, Example Corp utiliza **AWS1:ExampleRole** para obtener acceso a los recursos de la cuenta.

Este es el modo en que el otro cliente podría acceder de nuevo sin autorización a sus recursos. Dado que este otro cliente ha engañado a Example Corp para actuar en los recursos de forma accidental, Example Corp se ha convertido en un "suplente confuso".

Example Corp puede abordar el problema del suplente confuso al solicitarle que incluya la verificación de la condición `ExternalId` en la política de confianza del rol. Example Corp genera un único valor de `ExternalId` para cada cliente y utiliza ese valor en su solicitud para asumir el rol. El valor de `ExternalId` debe ser único entre los clientes de Example Corp y tiene que estar controlado por Example Corp, no por sus clientes. Este es el motivo por el que lo recibe de Example Corp y que no crea el suyo propio. Esto evita que Example Corp sea un suplente confuso y conceda acceso a los recursos de AWS de otra cuenta.

En nuestro caso, imagine que el identificador único de Example Corp para usted es 12345, y su identificador para el otro cliente es 67890. Estos identificadores están simplificados para este ejemplo. Por lo general, estos identificadores son GUID. Suponiendo que estos identificadores son exclusivos para cada cliente de Example Corp, son valores confidenciales que deben utilizarse para el ID externo. 

Example Corp le proporciona el valor de ID externo 12345. A continuación, deberá añadir un elemento `Condition` a la política de confianza del rol que exige que el valor [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts) sea 12345, como a continuación:

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Principal": {
      "AWS": "Example Corp's AWS Account ID"
    },
    "Action": "sts:AssumeRole",
    "Condition": {
      "StringEquals": {
        "sts:ExternalId": "12345"
      }
    }
  }
}
```

------

El elemento Condition (Condición) de esta política permite a Example Corp asumir el rol solo cuando la llamada a la API AssumeRole incluye el valor de ID externo 12345. Example Corp se asegura de que cada vez que se asume un rol en nombre de un cliente, siempre incluye el valor de ID externo del cliente en la llamada a AssumeRole. Incluso aunque otro cliente suministre el ARN a Example Corp, no puede controlar el ID externo que Example Corp incluye en su solicitud a AWS. Esto ayuda a impedir que un cliente no autorizado acceda a los recursos.

El siguiente diagrama ilustra este ejemplo.

![\[Cómo mitigar un problema de suplente confuso.\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/confuseddeputymitigation2.png)


1. Como anteriormente, al empezar a utilizar el servicio de Example Corp, usted proporciona el ARN de **AWS1:ExampleRole** a Example Corp.

1.  Cuando Example Corp usa ese ARN del rol para asumir el rol **AWS1:ExampleRole**, Example Corp incluye el ID externo (12345) en la llamada a la API AssumeRole. El ID externo coincide con la política de confianza del rol, por lo que la llamada AssumeRole a la API funciona y Example Corp obtiene las credenciales de seguridad temporales para acceder a los recursos de la cuenta de Cuenta de AWS.

1. Otro cliente de AWS también ha empezado a utilizar los servicios de Example Corp y, como antes, también proporciona el ARN de **AWS1: ExampleRole** para que lo utilice Example Corp. 

1. Sin embargo, ahora, cuando Example Corp intenta asumir el rol **AWS1:ExampleRole**, proporciona el ID externo asociado con el otro cliente (67890). El otro cliente no puede cambiarlo. Example Corp lo hace porque la solicitud para utilizar el rol procede de otro cliente, por lo que 67890 indica la circunstancia en la que actúa Example Corp. Dado que ha agregado una condición con su propio ID externo (12345) a la política de confianza de **AWS1:ExampleRole**, la llamada a la API AssumeRole provoca un error. Así se evita que el otro cliente obtenga un acceso no autorizado a los recursos de su cuenta (indicado por la "X" roja en el diagrama).

El ID externo ayuda a impedir que cualquier otro cliente engañe a Example Corp para que acceda a sus recursos.

## Prevención del suplente confuso entre servicios
<a name="cross-service-confused-deputy-prevention"></a>

En el siguiente diagrama, se muestra el problema del suplente confuso entre servicios mediante el ejemplo de interacción entre CloudTrail y Amazon S3, en el que una persona no autorizada escribe los registros de CloudTrail en un bucket de Amazon S3 al que no está autorizada a acceder.

![\[A una persona no autorizada se le concede acceso a un bucket de Amazon S3 de otra cuenta mediante la entidad principal del servicio de CloudTrail.\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/cross-service-confused-deputy1.png)


Para evitar que una persona no autorizada utilice la confianza de una entidad principal de AWS para acceder a sus recursos, las entidades principales del servicio de AWS incluyen información sobre el recurso de AWS, la Cuenta de AWS y la organización de AWS en nombre de la que actúan.

Esta información está disponible en valores clave de condición global que se pueden utilizar en una política de recursos o en una política de control de recursos para las solicitudes realizadas por las entidades principales del servicio de AWS. Le recomendamos que utilice[aws:SourceArn](reference_policies_condition-keys.md#condition-keys-sourcearn), [aws:SourceAccount](reference_policies_condition-keys.md#condition-keys-sourceaccount), [aws:SourceOrgID](reference_policies_condition-keys.md#condition-keys-sourceorgid) o [aws:SourceOrgPaths](reference_policies_condition-keys.md#condition-keys-sourceorgpaths) en sus políticas de recursos siempre que se conceda permiso a una entidad principal del servicio de AWS para acceder a uno de sus recursos. Estas claves de condición le permiten comprobar en sus políticas de recursos o políticas de control de recursos que las entidades principales del servicio de AWS que acceden a sus recursos lo hacen en nombre de los recursos de AWS, las Cuentas de AWS o AWS Organizations previstos.
+ Use `aws:SourceArn` para permitir que una entidad principal del servicio de AWS acceda a sus recursos en nombre de un recurso específico, como una ruta de AWS CloudTrail específica o una flota de AppStream.
+ Use `aws:SourceAccount` para permitir que una entidad principal del servicio de AWS acceda a sus recursos en nombre de un usuario de Cuenta de AWS específico.
+ Use `aws:SourceOrgID` para permitir que una entidad principal del servicio de AWS acceda a sus recursos en nombre de un usuario de AWS Organizations específico.
+ Use `aws:SourceOrgPaths` para permitir que la entidad principal del servicio de AWS acceda a sus recursos en nombre de una ruta de AWS Organizations específica.

En el siguiente diagrama, se muestra el escenario del suplente confuso entre servicios cuando un recurso se configura con la clave contextual de condición global `aws:SourceAccount` y una persona no autorizada de otra cuenta intenta acceder a recursos de AWS a los que no debe tener acceso.

![\[A una persona no autorizada se le deniega acceso a un bucket de Amazon S3 de otra cuenta mediante la entidad principal del servicio de CloudTrail.\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/cross-service-confused-deputy2.png)


El uso de las claves de condición global `aws:SourceArn`, `aws:SourceAccount`, `aws:SourceOrgID` y `aws:SourceOrgPaths` en una política le permite garantizar que las entidades principales del servicio accedan a sus recursos en su nombre. Recomendamos utilizar estas claves de condición siempre que se conceda acceso a uno de sus recursos a una entidad principal del servicio de AWS. 

**nota**  
Algunas interacciones de Servicio de AWS tienen controles adicionales para evitar problemas de suplente confuso entre servicios que ponen a prueba el acceso de los usuarios a un recurso. Por ejemplo, cuando se concede una clave de KMS a un Servicio de AWS, AWS KMS utiliza el contexto de cifrado asociado al recurso y la concesión de clave para evitar problemas de suplente confuso entre servicios.  
Consulte la documentación de los servicios que utiliza para obtener más información sobre los mecanismos específicos de cada servicio que pueden ayudar a evitar los riesgos de suplente confuso entre servicios y sobre si `aws:SourceArn`, `aws:SourceAccount`, `aws:SourceOrgID` y `aws:SourceOrgPaths` son compatibles.

## Protección del suplente confuso entre servicios con políticas basadas en recursos
<a name="cross-service-confused-deputy-prevention-resource"></a>

La siguiente política de ejemplo concede a la entidad principal del servicio de `cloudtrail.amazonaws.com` acceso al bucket de Amazon S3, arn:aws:s3:::amzn-s3-demo-bucket1, solo cuando la entidad principal del servicio actúa en nombre de Cuenta de AWS 111122223333.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "CloudTrailAclCheck",
            "Effect": "Allow",
            "Principal": {"Service": "cloudtrail.amazonaws.com"},
            "Action": "s3:GetBucketAcl",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket1",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "111122223333"
                }
            }
        },
        {
            "Sid": "AWSCloudTrailWrite",
            "Effect": "Allow",
            "Principal": {"Service": "cloudtrail.amazonaws.com"},
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket1/[optionalPrefix]/Logs/myAccountID/*",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "111122223333"
                }
            }
        }
    ]
}
```

------

Esta política de bucket de ejemplo concede a la entidad principal del servicio de `appstream.amazonaws.com` acceso al script de powershell examplefile.psh en s3://amzn-s3-demo-bucket2 solo cuando actúa en nombre de la flota de Amazon AppStream especificada, especificando el ARN de la flota con `aws:SourceArn`.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": [
                    "appstream.amazonaws.com"
                ]
            },
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket2/examplefile.psh",
            "Condition": {
                "ArnEquals": {
                    "aws:SourceArn": "arn:aws:appstream:us-east-1:111122223333:fleet/ExampleFleetName"
                } 
            }
        }
    ]
}
```

------

## Protección del suplente confuso entre servicios con políticas de control de recursos
<a name="cross-service-confused-deputy-prevention-resource-control"></a>

Puede utilizar las políticas de control de recursos (RCP) para aplicar controles de suplente confuso entre servicios a los recursos compatibles de Servicios de AWS. Las RCP le permiten aplicar de forma centralizada controles de suplente confuso entre servicios a sus recursos. Puede utilizar claves de condición como `aws:SourceOrgId` y `aws:SourceOrgPaths` con las RCP adjuntas a su AWS Organizations, unidades organizativas (OU) o Cuentas de AWS dentro de su organización sin agregar declaraciones a políticas basadas en recursos específicos. Para obtener más información acerca de las RCP y los servicios compatibles, consulte [Políticas de control de recursos (RCP)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) en la *Guía del usuario de AWS Organizations*.

En el siguiente ejemplo, la RCP deniega a las entidades principales del servicio de AWS el acceso a los buckets de Amazon S3 de sus cuentas miembro cuando `aws:SourceOrgID` no es igual a o-ExampleOrg. Debe haber un permiso correspondiente en la política basada en recursos del bucket de S3 para permitir que las entidades principales del Servicio de AWS tengan un `SourceOrgID` igual a o-ExampleOrg.

Esta política aplica el control solo a las solicitudes de las entidades principales del servicio (`"Bool": {"aws:PrincipalIsAWSService": "true"}`) que tienen la clave `aws:SourceAccount` (`"Null": {"aws:SourceAccount": "false"}`), de modo que las integraciones de servicios que no requieren el uso de la clave de condición y las llamadas de las entidades principales no se ven afectadas. Si la clave de condición `aws:SourceAccount` está presente en el contexto de la solicitud, se evaluará la condición nula como verdadera, lo que provocará que se aplique `aws:SourceOrgID`. Utilizamos `aws:SourceAccount` en lugar de `aws:SourceOrgID` en el operador de condición nula para que el control siga siendo válido si la solicitud se origina en una cuenta que no pertenece a una organización.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "RCPEnforceConfusedDeputyProtectionForS3",
      "Effect": "Deny",
      "Principal": "*",
      "Action": [
        "s3:*"
      ],
      "Resource": "*",
      "Condition": {
        "StringNotEqualsIfExists": {
          "aws:SourceOrgID": "o-ExampleOrg"
        },
        "Null": {
          "aws:SourceAccount": "false"
        },
        "Bool": {
          "aws:PrincipalIsAWSService": "true"
        }
      }
    }
  ]
}
```

------

# Escenarios habituales en los roles de IAM
<a name="id_roles_common-scenarios"></a>

Al igual que sucede con la mayoría de las características de AWS, hay dos formas de utilizar un rol: de forma interactiva en la consola de IAM o con programas, con la AWS CLI, Tools for Windows PowerShell o la API.
+ Los usuarios de IAM de su cuenta que usan la consola de IAM pueden *cambiar a* un rol para utilizar temporalmente los permisos del rol en la consola. Los usuarios renuncian a sus permisos originales y adoptan los permisos asignados al rol. Cuando el usuario deja de utilizar el rol, sus permisos originales se restablecen.
+ Una aplicación o un servicio que AWS ofrece (como Amazon EC2) puede *asumir* un rol solicitando credenciales de seguridad temporales para un rol con el que realizar solicitudes programadas a AWS. Un rol se utiliza de este modo para no tener que compartir ni mantener credenciales de seguridad a largo plazo (por ejemplo, mediante la creación de un usuario de IAM) para todas las entidades que requieran acceso a un recurso.

**nota**  
Esta guía utiliza las frases *cambiar a un rol* y *asumir un rol* indistintamente.

La forma más sencilla de utilizar roles consiste en conceder a los usuarios de IAM permisos para cambiar a los roles que usted crea dentro de su propia Cuenta de AWS o en otra. De esta forma, pueden cambiar de roles con facilidad utilizando la consola de IAM para utilizar permisos que usted no quiere que tengan normalmente y salir de los roles para renunciar a los permisos. Esto es útil para evitar el acceso *accidental* a recursos confidenciales o su modificación.

Para informarse de los usos de roles más complejos, como la concesión de acceso a aplicaciones y servicios, o a usuarios externos federados, puede llamar a la API `AssumeRole`. Esta llamada a la API devuelve un conjunto de credenciales temporales que la aplicación puede utilizar en las llamadas a la API posteriores. Las acciones que se intenten efectuar con las credenciales temporales solo tienen los permisos que el rol asociado les concede. Una aplicación no tiene que "salir" del rol de la misma forma que lo hace un usuario en la consola; en su lugar, la aplicación simplemente deja de utilizar las credenciales temporales y vuelve a realizar llamadas con las credenciales originales.

Los usuarios federados inician sesión con las credenciales de un proveedor de identidades (IdP). A continuación, AWS proporciona credenciales temporales al proveedor de identidades de confianza para que las transmita al usuario y que este las incluya en las solicitudes de recursos de AWS posteriores. Estas credenciales proporcionan los permisos concedidos al rol asignado.

En esta sección se proporciona información general sobre las situaciones siguientes:
+ [Proporcionar a un usuario de IAM de una Cuenta de AWS propia acceso a recursos de otra cuenta propia](id_roles_common-scenarios_aws-accounts.md)
+ [Proporcionar acceso a cargas de trabajo ajenas a AWS](id_roles_common-scenarios_non-aws.md)
+ [Proporcionar acceso a usuarios de IAM de Cuentas de AWS que le pertenezcan a terceros](id_roles_common-scenarios_third-party.md)
+ [Proporcionar acceso a servicios ofrecidos por AWS a recursos de AWS](id_roles_common-scenarios_services.md)
+ [Proporcionar acceso a usuarios autenticados externamente (identidad federada)](id_roles_common-scenarios_federated-users.md)

# Acceso para un usuario de IAM en otra Cuenta de AWS propia
<a name="id_roles_common-scenarios_aws-accounts"></a>

Puede conceder a los usuarios de IAM permiso para cambiar de roles en su Cuenta de AWS o a los roles definidos en otras Cuentas de AWS propias. 

**nota**  
Si desea conceder acceso a una cuenta de la que no es propietario o no tiene control, consulte [Acceder a las Cuentas de AWS que le pertenezcan a terceros](id_roles_common-scenarios_third-party.md) más adelante en este tema. 

Imagine que dispone de instancias de Amazon EC2 que son de vital importancia para su organización. En lugar de conceder directamente permiso a los usuarios para finalizar las instancias, puede crear un rol con estos privilegios. A continuación, permita que los administradores cambien de rol cuando necesiten terminar una instancia. Al hacer esto, se añaden las siguientes capas de protección a las instancias:
+ Debe conceder explícitamente permiso a los usuarios para asumir el rol.
+ Los usuarios deben cambiar de rol de forma activa con la Consola de administración de AWS o asumir el rol utilizando la AWS CLI o la API de AWS.
+ Puede añadir una protección Multi-Factor Authentication (MFA) al rol para que únicamente los usuarios que inicien sesión con un dispositivo MFA puedan asumir el rol. Para obtener información sobre cómo configurar un rol para que los usuarios que lo asuman deban primero autenticarse mediante la autenticación multifactor (MFA), consulte [Acceso seguro a la API con MFA](id_credentials_mfa_configure-api-require.md).

Recomendamos utilizar este enfoque para aplicar el *principio de privilegio mínimo*. Esto significa limitar el uso de permisos elevados únicamente cuando sean necesarios para realizar tareas específicas. Con los roles puede ayudar a impedir cambios accidentales en entornos confidenciales, especialmente si los combina con un proceso de [auditoría](cloudtrail-integration.md) con el fin de garantizar que los roles solo se utilizan cuando sean necesarios.

Al crear un rol con este fin, debe especificar las cuentas mediante el ID cuyos usuarios necesitan obtener acceso en el elemento `Principal` de la política de confianza del rol. Puede conceder permisos a usuarios específicos de estas otras cuentas para cambiar de rol. Consulte [¿Qué es IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html) para saber si las entidades principales de las cuentas fuera de su zona de confianza (cuenta u organización de confianza) tienen acceso para asumir sus roles.

Un usuario de una cuenta puede cambiar de rol en la misma cuenta o en una cuenta diferente. Al utilizar el rol, el usuario solo puede realizar las acciones y obtener acceso únicamente a los recursos permitidos por el rol; sus permisos originales de usuario se suspenden. Si el usuario deja de utilizar el rol, sus permisos originales se restablecen.

## Situación de ejemplo en la que se usan cuentas de desarrollo y producción separadas
<a name="id_roles_common-scenarios_aws-accounts-example"></a>

Imagine que la organización tiene varias Cuentas de AWS para aislar su entorno de desarrollo del de producción. Los usuarios de la cuenta de desarrollo podrían necesitar ocasionalmente acceder a los recursos en la cuenta de producción. Por ejemplo, es posible que necesite el acceso entre cuentas al promocionar una actualización desde el entorno de desarrollo al entorno de producción. Aunque podría crear identidades distintas (y contraseñas) para los usuarios que trabajan en las dos cuentas, la administración de credenciales de varias cuentas dificulta la administración de las identidades. En la siguiente figura, todos los usuarios se administran en la cuenta de desarrollo, pero algunos desarrolladores exigen acceso limitado a la cuenta de producción. La cuenta de desarrollo tiene dos grupos: Evaluadores y Desarrolladores, y cada grupo tiene su propia política.

![\[Utilice un rol para delegar permisos a un usuario en otra cuenta\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/roles-usingroletodelegate.png)


1. En la cuenta de producción un administrador utiliza IAM para crear el rol `UpdateApp` en dicha cuenta. En el rol, el administrador define una política de confianza que especifica la cuenta de desarrollo como `Principal`, lo que significa que los usuarios autorizados de la cuenta de desarrollo pueden utilizar el rol `UpdateApp`. El administrador también define una política de permisos para el rol que especifica los permisos de lectura y escritura del bucket de Amazon S3 denominado `productionapp`.

   El administrador comparte entonces la información pertinente con cualquier usuario que necesite asumir el rol. Dicha información es el número de cuenta y el nombre del rol (para usuarios de la consola de AWS) o el Nombre de recurso de Amazon (ARN) (para acceso de API de AWS CLI o AWS). El ARN del rol podría parecerse a `arn:aws:iam::123456789012:role/UpdateApp`, donde el rol se denomina `UpdateApp` y el rol se creó en el número de cuenta 123456789012.
**nota**  
El administrador puede configurar de forma opcional el rol para que los usuarios que lo asuman deban primero autenticarse mediante la opción Multi-Factor Authentication (MFA). Para obtener más información, consulte [Acceso seguro a la API con MFA](id_credentials_mfa_configure-api-require.md). 

1. En la cuenta de desarrollo un administrador concede a los miembros del grupo Desarrolladores permiso para cambiar de rol. Esto se realiza mediante la concesión de permiso al grupo Desarrolladores para llamar a la API AWS Security Token Service de AWS STS (`AssumeRole`) para el rol `UpdateApp`. Cualquier usuario de IAM que pertenezca al grupo Desarrolladores de la cuenta de desarrollo ahora puede cambiar al rol `UpdateApp` en la cuenta de producción. Otros usuarios que no están en el grupo Desarrolladores no tienen permiso para cambiar de rol y, por lo tanto, no pueden obtener acceso al bucket de S3 en la cuenta de producción.

1. El usuario solicita cambios de rol:
   + Consola de AWS: el usuario selecciona el nombre de la cuenta en la barra de navegación y elige **Switch Role (Cambiar rol)**. El usuario especifica el ID de la cuenta (o alias) y el nombre del rol. O bien, el usuario puede hacer clic en un enlace enviado por correo electrónico enviado por el administrador. Este enlace redirigirá al usuario a la página **Switch Role (Cambiar rol)** con los detalles ya completados.
   + API de AWS/AWS CLI: un usuario del grupo Desarrolladores de la cuenta de desarrollo llama a la función `AssumeRole` para obtener las credenciales para el rol `UpdateApp`. El usuario especifica el ARN del rol `UpdateApp` como parte de la llamada. Si un usuario del grupo Evaluadores realiza la misma solicitud, esta no podrá llevarse a cabo, ya que los evaluadores no tienen permiso para llamar a `AssumeRole` para solicitar el ARN del rol `UpdateApp`.

1. AWS STS devuelve credenciales temporales:
   + Consola de AWS: AWS STS verifica la solicitud con la política de confianza del rol para garantizar que la solicitud procede de una entidad de confianza (es decir, la cuenta de desarrollo). Tras realizar la verificación, AWS STS devuelve [credenciales de seguridad temporales ](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) a la consola de AWS.
   + API/CLI: AWS STS verifica la solicitud con la política de confianza del rol para garantizar que la solicitud procede de una entidad de confianza (es decir, la cuenta de desarrollo). Tras realizar la verificación, AWS STS devuelve [credenciales de seguridad temporales](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) a la aplicación.

1. Las credenciales temporales permiten el acceso a los recursos de AWS:
   + Consola de AWS: la consola de AWS utiliza las credenciales temporales en nombre del usuario para todas las acciones de consola posteriores, en este caso, para leer y escribir en el bucket `productionapp`. La consola no puede obtener acceso a cualquier otro recurso en la cuenta de producción. Si el usuario deja de utilizar el rol, los permisos del usuario vuelven a los permisos originales antes de cambiar de rol.
   + API/CLI: la aplicación utiliza las credenciales de seguridad temporales para actualizar el bucket de `productionapp`. Con las credenciales de seguridad temporales, la aplicación solo puede leer y escribir en el bucket de `productionapp` y no puede obtener acceso a cualquier otro recurso en la cuenta de producción. La aplicación no tiene que dejar de utilizar el rol, sino que, en cambio, deja de utilizar las credenciales temporales y utiliza las credenciales originales en las llamadas API posteriores.

## Recursos adicionales
<a name="id_roles_common-scenarios_more-info"></a>

Para obtener más información, consulte los siguientes temas:
+ [Tutorial de IAM: delegación del acceso entre cuentas de AWS mediante roles de IAM](tutorial_cross-account-with-roles.md)

# Acceso para cargas de trabajo que no sean de AWS
<a name="id_roles_common-scenarios_non-aws"></a>

Un [rol de IAM](id_roles.md) es un objeto de AWS Identity and Access Management (IAM) al que se le asignan [permisos](access_policies.md). Cuando se [asume ese rol](id_roles_manage-assume.md) mediante una identidad de IAM o una identidad externa a AWS, proporciona credenciales de seguridad temporales para la sesión de rol. Es posible que tenga cargas de trabajo ejecutándose en un centro de datos u otra infraestructura fuera de AWS que deban acceder a los recursos de AWS. En lugar de crear, distribuir y administrar claves de acceso de larga duración, puede utilizar AWS Identity and Access Management Roles Anywhere (IAM Roles Anywhere) para autenticar las cargas de trabajo ajenas a AWS. IAM Roles Anywhere utiliza certificados X.509 de la entidad de certificación (CA) para autenticar identidades y proporcionar acceso seguro a Servicios de AWS con las credenciales temporales proporcionadas por un rol de IAM.

**Para utilizar IAM Roles Anywhere**

1. Configure una CA mediante [AWS Private Certificate Authority](https://docs.aws.amazon.com/privateca/latest/userguide/PcaWelcome.html), o bien utilice una CA de su propia infraestructura de PKI.

1. Después de configurar una CA, debe crear un objeto en IAM Roles Anywhere denominado *anclaje de confianza*. Este anclaje establece la confianza entre IAM Roles Anywhere y su CA para la autenticación.

1. A continuación, puede configurar los roles de IAM existentes o crear otros nuevos que confíen en el servicio de IAM Roles Anywhere.

1. Autentique las cargas de trabajo que no sean de AWS con IAM Roles Anywhere mediante el anclaje de veracidad. AWS concede a la carga de trabajo que no es de AWS credenciales temporales para el rol de IAM que tiene acceso a sus recursos de AWS.

## Recursos adicionales
<a name="id_roles_non-aws_additional_resources"></a>

Los siguientes recursos pueden ayudarlo a obtener más información sobre cómo proporcionar acceso a las cargas de trabajo que no son de AWS.
+ Para obtener más información sobre cómo configurar IAM Roles Anywhere, consulte [Qué es AWS Identity and Access Management Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) en la *Guía del usuario de IAM Roles Anywhere*.
+ A fin de obtener información sobre cómo configurar una infraestructura de clave pública (PKI) para IAM Roles Anywhere, consulte [IAM Roles Anywhere with an external certificate authority](https://aws.amazon.com/blogs/) en el *Blog de seguridad de AWS*.

# Acceder a las Cuentas de AWS que le pertenezcan a terceros
<a name="id_roles_common-scenarios_third-party"></a>

Cuando terceros necesitan obtener acceso a recursos de AWS de su organización, puede utilizar roles para delegarles el acceso. Por ejemplo, puede que un tercero proporcione un servicio de administración de sus recursos de AWS. Con los roles de IAM, puede concederle acceso a sus recursos de AWS a terceros sin tener que compartir sus credenciales de seguridad de AWS. En vez de ello, el tercero puede obtener acceso a sus recursos de AWS asumiendo un rol que usted crea en su Cuenta de AWS. Consulte [¿Qué es IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html) para saber si las entidades principales de las cuentas fuera de su zona de confianza (cuenta u organización de confianza) tienen acceso para asumir sus roles.

Los terceros deben proporcionarle la siguiente información para que pueda crear un rol que puedan asumir:
+ **El ID de Cuenta de AWS del tercero**. Especifique su ID de Cuenta de AWS como entidad principal cuando defina la política de confianza del rol.
+ **Un ID externo para la asociación exclusiva con el rol**. El ID externo puede ser cualquier identificador secreto que usted y el tercero conozcan. Por ejemplo, puede utilizar un ID de factura entre usted y el tercero, pero no utilice nada que pueda adivinarse, como el nombre o el número de teléfono del tercero. Debe especificar este ID cuando defina la política de confianza del rol. El tercero debe proporcionar este ID cuando asuma el rol.
+ **Los permisos que el tercero necesita para poder trabajar con sus recursos de AWS**. Debe especificar estos permisos cuando defina la política de permisos del rol. Esta política define qué acciones pueden ejecutar y a qué recursos pueden obtener acceso.

Después de crear el rol, debe proporcionar el nombre de recurso de Amazon (ARN) del rol al tercero. El ARN del rol es necesario para asumir el rol.

**importante**  
Cuando concede acceso a terceros a sus recursos de AWS, estos pueden obtener acceso a cualquier recurso que especifique en la política. El uso que efectúen de sus recursos se le facturará a usted. Asegúrese de que limita el uso de los recursos de forma adecuada.

## ID externos para el acceso de terceros
<a name="id_roles_third-party_external-id"></a>

Un ID externo permite al usuario que asume el rol afirmar las circunstancias en las que opera. También ofrece al propietario de la cuenta una forma de permitir asumir el rol únicamente en circunstancias específicas. La función principal del ID externo es abordar y prevenir [El problema del suplente confuso](confused-deputy.md).

**importante**  
AWS no trate el ID externo como un secreto. Después de crear un secreto como un par de claves de acceso o una contraseña en AWS, no puede verlos de nuevo. Cualquier usuario con permiso para ver el rol puede ver el ID externo de dicho rol. 

## ¿Cuándo debería utilizar un ID externo?
<a name="external-id-use"></a>

Utilice un ID externo en las siguientes situaciones:
+ Es un propietario de la Cuenta de AWS y ha configurado un rol para un tercero que obtiene acceso a otras Cuentas de AWS, además de la suya. Debe pedir a ese tercero un ID externo que incluye cuándo asume su rol. A continuación, busque el ID externo en la política de confianza de su rol. De este modo se garantiza que el tercero puede asumir su rol solo cuando actúa en su nombre.
+ Se encuentra en la posición de asumir roles en nombre de diferentes clientes como Example Corp en nuestra situación anterior. Debe asignar un ID externo único a cada cliente e indicarle que lo agregue a la política de confianza de su rol. A continuación, deberá asegurarse de incluir siempre el ID externo correcto en sus solicitudes para asumir roles.

  Es muy probable que ya tenga un identificador único para cada uno de sus clientes y que este ID único sea suficiente para su uso como ID externo. El ID externo no es un valor especial que deba crear de forma explícita o realizar un seguimiento por separado, solo para este fin.

  Siempre debe especificar el ID externo en las llamadas a la API `AssumeRole`. Además, cuando un cliente le ofrezca un ARN de rol, pruebe si puede asumir el rol tanto con como sin el ID externo correcto. Si puede asumir el rol sin el ID externo correcto, no almacene el ARN de rol del cliente en su sistema. Espere hasta que el cliente haya actualizado la política de confianza de rol para solicitar el ID externo correcto. De esta forma ayuda a sus clientes a hacer lo correcto, lo que ayuda a mantenerles a ambos protegidos frente al problema del suplente confuso.

## Escenario de ejemplo con un ID externo
<a name="id_roles_third-party_example"></a>

Por ejemplo, digamos que decide contratar a una empresa externa denominada Example Corp para supervisar su Cuenta de AWS y ayudarlo a optimizar los costos. A fin de realizar un seguimiento de su gasto diario, Example Corp necesita acceder a los recursos de AWS. Example Corp también monitoriza muchas otras cuentas de AWS para otros clientes.

No conceda a Example Corp acceso a un usuario de IAM y sus credenciales a largo plazo en su cuenta de AWS. En su lugar, utilice un rol de IAM y sus credenciales de seguridad temporales. Un rol de IAM proporciona un mecanismo para permitir que un tercero acceda a sus recursos de AWS sin necesidad de compartir credenciales a largo plazo (por ejemplo, una clave de acceso del usuario de IAM).

Puede utilizar un rol de IAM para establecer una relación de confianza entre su Cuenta de AWS y la cuenta de Example Corp. Después de que se establezca esta relación, un miembro de la cuenta de Example Corp puede llamar a la API de AWS Security Token Service [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) para obtener credenciales de seguridad temporales. A continuación, los miembros de Example Corp pueden utilizar las credenciales para obtener acceso a los recursos de AWS en su cuenta. 

**nota**  
Para obtener más información acerca de AssumeRole y de otras operaciones de la API de AWS que puede llamar para obtener credenciales de seguridad temporales, consulte [Comparación de credenciales AWS STS](id_credentials_sts-comparison.md).

A continuación presentamos un desglose más detallado de la situación:

1. Contrata a Example Corp para que cree un único identificador de cliente para usted. Te proporcionan este ID de cliente único y su número de Cuenta de AWS. Usted necesita esta información para crear un rol de IAM en el siguiente paso. 
**nota**  
Example Corp puede utilizar cualquier valor de cadena que desee para el ExternalId, siempre que sea exclusivo para cada cliente. Puede ser un número de cuenta de cliente o incluso una cadena de caracteres aleatoria, siempre que no haya dos clientes con el mismo valor. No pretende ser un "secreto". Example Corp debe proporcionar el valor ExternalId a cada cliente. Lo fundamental es que el valor lo debe generar Example Corp y ***no*** sus clientes, para garantizar que cada ID externo sea único.

1. Puede iniciar sesión en AWS y crear un rol de IAM que otorgue acceso a Example Corp a sus recursos. Como cualquier rol de IAM, el rol tiene dos políticas: una política de permisos y una política de confianza. La política de confianza del rol especifica quién puede asumir el rol. En nuestro caso, la política especifica el número de Cuenta de AWS de Example Corp como el `Principal`. Esto permite que las identidades de la cuenta asuman el rol. Además, se agrega un elemento `[Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition)` a la política de confianza. Esta `Condition` prueba la clave de contexto `ExternalId` para garantizar que coincide con el ID de cliente único de Example Corp. Por ejemplo:

   ```
       "Principal": {"AWS": "Example Corp's Cuenta de AWS ID"},
       "Condition": {"StringEquals": {"sts:ExternalId": "Unique ID Assigned by Example Corp"}}
   ```

1. La política de permisos del rol especifica qué permite realizar dicho rol. Por ejemplo, podría especificar que el rol permite administrar únicamente los recursos de Amazon EC2 y Amazon RDS, pero no los recursos de usuarios o grupos de IAM. En nuestro escenario de ejemplo, utiliza la política de permisos para ofrecer a Example Corp acceso de solo lectura a todos los recursos de la cuenta.

1. Después de crear el rol, debe proporcionar el nombre de recurso de Amazon (ARN) del rol a Example Corp.

1. Cuando Example Corp necesita acceder a los recursos de AWS, un miembro de la compañía llama a la API AWS de `sts:AssumeRole`. La llamada incluye el ARN de la función que se ha de asumir y el parámetro ExternalId que se corresponde con el ID de cliente.

Si la solicitud proviene de alguien que utiliza la Cuenta de AWS de Example Corp y si el ARN de rol y el ID externo son correctos, la solicitud se realiza correctamente. A continuación, proporciona credenciales de seguridad temporales que Example Corp puede utilizar para obtener acceso a los recursos de AWS que permite su rol.

En otras palabras, cuando una política de roles incluye un ID externo, cualquiera que desee asumir el rol debe ser principal en el rol y debe incluir el ID externo correcto.

## Puntos clave para los ID externos
<a name="id_roles_third-party_key-points"></a>
+ En un entorno de varios inquilinos en el que se admiten varios clientes con cuentas de AWS diferentes, recomendamos utilizar un ID externo por cada Cuenta de AWS. Este ID debe ser una cadena aleatoria generada por el tercero.
+ Para requerir que el tercero proporcione un ID externo al asumir un rol, actualice la política de confianza del rol con el ID externo de su elección.
+ Para proporcionar un ID externo cuando asuma un rol, utilice la AWS CLI o la API de AWS para asumir ese rol. Para obtener más información, consulte la operación de la API [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) o la operación de la CLI [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html).
+ El valor `ExternalId` debe tener 2 caracteres como mínimo y 1224 como máximo. El valor debe ser alfanumérico sin espacio en blanco. También puede incluir los símbolos siguientes: más (\$1), igual (=), coma (,), punto (.), arroba (@), dos puntos (:), barra inclinada (/) y guion (-).

## Recursos adicionales
<a name="id_roles_third-party_additional_resources"></a>

Los siguientes recursos pueden ayudarlo a obtener más información sobre cómo proporcionar acceso a las Cuentas de AWS que le pertenezcan a terceros.
+ Para obtener información sobre cómo permitir que otros realicen acciones en su Cuenta de AWS, consulte [Crear un rol mediante políticas de confianza personalizadas](id_roles_create_for-custom.md).
+ Para obtener información sobre cómo conceder permiso a fin de cambiar a un rol, consulte [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).
+ Para obtener información sobre cómo crear y proporcionar credenciales de seguridad temporales a usuarios confiables, consulte [Permisos para credenciales de seguridad temporales](id_credentials_temp_control-access.md).

# Acceso a un servicio de AWS
<a name="id_roles_common-scenarios_services"></a>

Muchos servicios de AWS exigen el uso de roles para controlar a qué tiene acceso dicho servicio. Un rol que asume un servicio para realizar acciones en su nombre se denomina [rol de servicio](id_roles.md#iam-term-service-role). Si un rol tiene un fin especializado para un servicio, puede categorizarse como [rol de servicio vinculado](id_roles.md#iam-term-service-linked-role). Consulte la [AWS documentación](https://docs.aws.amazon.com/) de cada servicio para ver si utiliza roles y para aprender a asignar un rol para que lo utilice el servicio.

Para obtener más información sobre cómo crear un rol para delegar el acceso a un servicio ofrecido por AWS, consulte [Crear un rol para delegar permisos a un servicio de AWS](id_roles_create_for-service.md).

# Acceder a usuarios autenticados externamente (federación de identidades)
<a name="id_roles_common-scenarios_federated-users"></a>

Es posible que los usuarios tengan ya identidades fuera de AWS, por ejemplo, en el directorio corporativo. Si estos usuarios necesitan trabajar con recursos de AWS (o con aplicaciones que necesiten acceso a dichos recursos), estos usuarios también necesitarán tener credenciales de seguridad de AWS. Puede utilizar un rol de IAM para especificar permisos para los usuarios con identidad federada de la organización o para un proveedor de identidad (IdP) externo.

**nota**  
Como práctica recomendada de seguridad, le recomendamos que administre el acceso de los usuarios en [IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/what-is.html) mediante la federación de identidades en lugar de crear usuarios de IAM. Para obtener más información acerca de situaciones específicas en las que se requiere un usuario de IAM, consulte [Cuándo crear un usuario de IAM (en lugar de un rol)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose).

## Federación de usuarios de una aplicación móvil o web con Amazon Cognito
<a name="id_roles_common-scenarios_federated-users-cognito"></a>

Si crea una aplicación móvil o web que tenga acceso a los recursos de AWS, esta aplicación necesita credenciales de seguridad para poder realizar solicitudes mediante programación en AWS. En la mayoría de escenarios de aplicaciones móviles, le recomendamos utilizar [Amazon Cognito](https://aws.amazon.com/cognito/). Puede utilizar este servicio con [AWS Mobile SDK para iOS](https://aws.amazon.com/sdkforios/) y [AWS Mobile SDK para Android y Fire OS](https://aws.amazon.com/sdkforandroid/) a fin de crear identidades exclusivas para usuarios y autenticarlos para proteger el acceso a sus recursos de AWS. Amazon Cognito es compatible con los mismos proveedores de identidad indicados en la sección siguiente, y también admite [identidades autenticadas por desarrollador](https://aws.amazon.com/blogs/mobile/amazon-cognito-announcing-developer-authenticated-identities) y acceso no autenticado (invitado). Amazon Cognito también ofrece operaciones de API para sincronizar los datos del usuario de modo que se preserven cuando cambia de un dispositivo a otro. Para obtener más información, consulte [Amazon Cognito para aplicaciones móviles](id_federation_common_scenarios.md#id_roles_providers_oidc_cognito). 

## Federación de usuarios con proveedores de servicio de identidad pública u OpenID Connect
<a name="id_roles_common-scenarios_federated-users-openId"></a>

Siempre que sea posible, utilice Amazon Cognito para escenarios de aplicaciones móviles y web. Amazon Cognito realiza la mayoría del trabajo en segundo plano con los servicios del proveedor de identidad pública. Funciona con los mismos servicios de terceros y también admite inicios de sesión anónimos. Sin embargo, en los escenarios más avanzados, puede trabajar directamente con un servicio de terceros como Login with Amazon, Facebook, Google o cualquier proveedor (IdP) compatible con OpenID Connect (OIDC). Para obtener más información sobre el uso de la federación OIDC con uno de estos servicios, consulte [Federación OIDC](id_roles_providers_oidc.md).

## Federación de usuarios con SAML 2.0
<a name="id_roles_common-scenarios_federated-users-saml20"></a>

Si su organización ya utiliza un paquete de software de proveedor de identidad que admite SAML 2.0 (Security Assertion Markup Language 2.0), puede crear una relación de confianza entre su organización como proveedor de identidad (IdP) y AWS como proveedor del servicio. Entonces podrá utilizar SAML para proporcionar a los usuarios un inicio de sesión único (SSO) federado para el acceso a la Consola de administración de AWS o acceso federado a las llamadas a operaciones de API de AWS. Por ejemplo, si su compañía utiliza Microsoft Active Directory y Active Directory Federation Services, puede realizar la federación con SAML 2.0. Para obtener más información sobre cómo federar usuarios con SAML 2.0, consulte [Federación SAML 2.0](id_roles_providers_saml.md).

## Federación de usuarios mediante la creación de una aplicación personalizada de agente de identidades
<a name="id_roles_common-scenarios_federated-users-idbroker"></a>

Si su almacén de identidades no es compatible con SAML 2.0, puede crear una aplicación personalizada de agente de identidades para llevar a cabo una función similar. La aplicación de agente autentica a los usuarios, solicita credenciales temporales para los usuarios de AWS y les proporciona acceso a los recursos de AWS. 

Por ejemplo, Example Corp. tiene muchos empleados que necesitan ejecutar aplicaciones internas que obtengan acceso a los recursos de AWS de la compañía. Los empleados ya tienen identidades en el sistema de autenticación e identidad de la compañía y Example Corp. no quiere crear otro usuario de IAM para cada empleado de la compañía.

Bob es un desarrollador de Example Corp. Para permitir que las aplicaciones internas de la compañía obtengan acceso a los recursos de AWS, Bob desarrolla una aplicación personalizada de agente de identidades. La aplicación verifica que los empleados hayan iniciado sesión en el sistema existente de autenticación e identidad de Example Corp., que podría utilizar LDAP, Active Directory u otro sistema. La aplicación de agente de identidades obtiene credenciales de seguridad temporales para los empleados. Este escenario es similar al anterior (una aplicación móvil que utiliza un sistema personalizado de autenticación), salvo que todas las aplicaciones que necesitan acceso a los recursos de AWS se ejecutan en la red corporativa y la compañía tiene un sistema existente de autenticación.

Para obtener credenciales de seguridad temporales, la aplicación de agente de identidades llama a `AssumeRole` o `GetFederationToken` para obtener credenciales de seguridad temporales, en función del modo en que Bob quiere administrar las políticas para los usuarios y el momento en el que las credenciales temporales caduquen. (Para obtener información sobre las diferencias entre estas operaciones de API, consulte [Credenciales de seguridad temporales en IAM](id_credentials_temp.md) y [Permisos para credenciales de seguridad temporales](id_credentials_temp_control-access.md)). La llamada devuelve credenciales de seguridad temporales que incluyen un token de sesión, una clave de acceso secreta y un ID de clave de acceso de AWS. La aplicación de agente de identidades pone a disposición de la aplicación interna de la compañía estas credenciales de seguridad temporales. La aplicación puede utilizar las credenciales temporales para realizar llamadas a AWS directamente. La aplicación almacena en caché las credenciales hasta que caducan y solicita un nuevo conjunto de credenciales temporales. La siguiente figura ilustra este escenario.

![\[Ejemplo de flujo de trabajo mediante la utilización de una aplicación de agentes de identidades personalizada\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/enterprise-authentication-with-identity-broker-application.diagram.png)


Este escenario tiene los siguientes atributos:
+ La aplicación de agente de identidades tiene permisos para obtener acceso a la API de Security Token Service (STS) de IAM para crear credenciales de seguridad temporales.
+ La aplicación de agente de identidades puede verificar que los empleados estén autenticados en el sistema existente de autenticación.
+ Los usuarios pueden obtener una dirección URL temporal que les proporcione acceso a Management Console de AWS (lo que se denomina inicio de sesión único).

Para obtener información sobre la creación de credenciales de seguridad, consulte [Comparación de credenciales AWS STS](id_credentials_sts-comparison.md). Para obtener más información sobre cómo las entidades principales federadas de SAML obtienen acceso a la Consola de administración de AWS, consulte [Concesión de acceso a la Consola de administración de AWS a las entidades principales federadas de SAML 2.0](id_roles_providers_enable-console-saml.md).

# Creación de roles de IAM
<a name="id_roles_create"></a>

Para crear un rol, puede utilizar Consola de administración de AWS, AWS CLI, Tools for Windows PowerShell o la API de IAM.

Si utiliza la Consola de administración de AWS, un asistente le guiará por los pasos de creación de un rol. El asistente varía ligeramente según si crea un rol para un servicio de AWS, una Cuenta de AWS o una entidad principal federada de SAML u OIDC.

**Roles para usuarios de IAM**  
Cree este rol para delegar permisos en su Cuenta de AWS o a roles definidos en otras Cuentas de AWS que posea. Un usuario de una cuenta puede cambiar de rol en la misma cuenta o en una cuenta diferente. Al utilizar el rol, el usuario solo puede realizar las acciones y obtener acceso únicamente a los recursos permitidos por el rol; sus permisos originales de usuario se suspenden. Si el usuario deja de utilizar el rol, sus permisos originales se restablecen.

Para obtener más información, consulte [Creación de un rol para delegar permisos a un usuario de IAM](id_roles_create_for-user.md).

A fin de obtener más información sobre la creación de roles para el acceso entre cuentas, consulte [Crear un rol mediante políticas de confianza personalizadas](id_roles_create_for-custom.md).

**Roles para servicios de AWS**  
Cree este rol para delegar permisos a un servicio que pueda realizar acciones en su nombre. El [rol de servicio](id_roles.md#iam-term-service-role) que transfiera a un servicio debe tener una política de IAM con los permisos que autoricen a ese servicio a realizar las acciones que tiene asociadas. Se requieren distintos permisos para cada servicio de AWS.

Para obtener más información sobre la creación de roles de servicio, consulte [Crear un rol para delegar permisos a un servicio de AWS](id_roles_create_for-service.md).

Para obtener más información sobre la creación de roles vinculados a servicios, consulte [Creación de un rol vinculado al servicio](id_roles_create-service-linked-role.md).

**Roles para la federación de identidades**  
Cree este rol para delegar permisos a los usuarios que ya tienen identidades fuera de AWS. Cuando se utiliza un proveedor de identidad, no es necesario crear un código de inicio de sesión personalizado ni administrar sus propias identidades de usuario. Sus usuarios externos inician sesión a través de un IdP, y usted puede conceder permisos a las identidades externas para utilizar los recursos de AWS en su cuenta. Los proveedores de identidades lo ayudan a proteger su cuenta de AWS, ya que no tiene que distribuir ni integrar en su aplicación credenciales de seguridad a largo plazo, como las claves de acceso.

Para obtener más información, consulte [Creación de un rol para un proveedor de identidad externo](id_roles_create_for-idp.md).

# Creación de un rol para delegar permisos a un usuario de IAM
<a name="id_roles_create_for-user"></a>

Puede utilizar roles de IAM para proporcionar acceso a sus recursos de AWS. Con roles de IAM puede establecer relaciones de *confianza* entre la cuenta que confía y otras cuentas de *confianza* de AWS. La cuenta que confía posee el recurso al que se obtiene acceso y la cuenta de confianza incluye los usuarios que necesitan obtener acceso al recurso. Sin embargo, es posible que otra cuenta sea propietaria de un recurso de su cuenta. Por ejemplo, la cuenta que confía podría permitir a la cuenta de confianza crear recursos, como, por ejemplo, crea objetos en un bucket de Amazon S3. En ese caso, la cuenta que crea el recurso es la propietaria del recurso y controla quién pueden tener acceso a dicho recurso.

Después de crear la relación de confianza, un usuario de IAM o una aplicación de la cuenta de confianza pueden utilizar la operación AWS Security Token Service (AWS STS) [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) de la API. Esta operación proporciona credenciales de seguridad temporales que permiten el acceso a los recursos de AWS de su cuenta.

Usted puede controlar ambas cuentas o un tercero puede controlar la cuenta con los usuarios. Si la otra cuenta con los usuarios se encuentra en una Cuenta de AWS que usted no controla, puede utilizar el atributo `externalId`. El ID externo puede ser cualquier palabra o número acordados entre usted y el administrador de la cuenta de terceros. Esta opción agrega automáticamente una condición a la política de confianza que permite al usuario asumir el rol únicamente si la solicitud incluye el correcto `sts:ExternalID`. Para obtener más información, consulte [Acceder a las Cuentas de AWS que le pertenezcan a terceros](id_roles_common-scenarios_third-party.md).

Para obtener información sobre cómo utilizar los roles para delegar permisos, consulte [Términos y conceptos de roles](id_roles.md#id_roles_terms-and-concepts). Para obtener más información sobre el uso de un rol de servicio para permitir que los servicios obtengan acceso a los recursos de su cuenta, consulte [Crear un rol para delegar permisos a un servicio de AWS](id_roles_create_for-service.md).

## Creación de un rol de IAM (consola)
<a name="roles-creatingrole-user-console"></a>

Puede utilizar la Consola de administración de AWS para crear un rol que un usuario de IAM pueda asumir. Por ejemplo, suponga que su organización tiene varias Cuentas de AWS para aislar un entorno de desarrollo de uno de producción. Para información general sobre cómo crear un rol que permita a usuarios de la cuenta de desarrollo acceder a los recursos de la cuenta de producción, consulte [Situación de ejemplo en la que se usan cuentas de desarrollo y producción separadas](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example).

**Permisos mínimos**  
Para realizar los siguientes pasos, debe tener al menos los siguientes permisos IAM:  
`access-analyzer:ValidatePolicy`
`iam:AttachRolePolicy`
`iam:CreatePolicy`
`iam:CreateRole`
`iam:GetAccountSummary`
`iam:GetPolicy`
`iam:GetPolicyVersion`
`iam:GetRole`
`iam:ListAccountAliases`
`iam:ListAttachedRolePolicies`
`iam:ListOpenIDConnectProviders`
`iam:ListPolicies`
`iam:ListRolePolicies`
`iam:ListRoles`
`iam:ListRoleTags`
`iam:ListSAMLProviders`

------
#### [ Console ]

1. Inicie sesión en Consola de administración de AWS y abra la consola IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación de la consola, elija **Roles** y, a continuación, seleccione **Crear rol**.

1. Elija el tipo de rol de **Cuenta de AWS**.

1. Para crear un rol para la cuenta, elija **Esta cuenta**. Para crear un rol para otra cuenta, elija **Otra Cuenta de AWS** e ingrese el **ID de cuenta** al que desea conceder acceso a los recursos.

   El administrador de la cuenta especificada puede conceder permiso para asumir este rol a cualquier usuario de IAM en esa cuenta. Para ello, el administrador asocia una política al usuario o grupo que concede permiso para la acción `sts:AssumeRole`. Esta política debe especificar el ARN del rol como `Resource`. 

1. Si concede permisos a los usuarios desde una cuenta que no controla y los usuarios van a asumir este rol mediante programación, seleccione **Requerir ID externo**. El ID externo puede ser cualquier palabra o número acordados entre usted y el administrador de la cuenta de terceros. Esta opción agrega automáticamente una condición a la política de confianza que permite al usuario asumir el rol únicamente si la solicitud incluye el correcto `sts:ExternalID`. Para obtener más información, consulte [Acceder a las Cuentas de AWS que le pertenezcan a terceros](id_roles_common-scenarios_third-party.md).
**importante**  
Si elige esta opción, restringe el acceso al rol únicamente a través de la API de AWS CLI, Tools for Windows PowerShell o API de AWS. Esto se debe a que no puede utilizar la consola de AWS para cambiar a un rol que tiene una condición `externalId` en su política de confianza. Sin embargo, puede crear este tipo de acceso mediante programación si escribe un script o una aplicación con el correspondiente SDK. Para obtener más información y un script de muestra, consulte [Cómo habilitar el acceso entre cuentas a la Consola de administración de AWS](https://aws.amazon.com/blogs/security/how-to-enable-cross-account-access-to-the-aws-management-console) en el blog de seguridad de AWS.

1. Si desea restringir el rol a aquellos usuarios que inicien sesión con autenticación multifactor (MFA), seleccione **Requerir MFA**. De esta forma se agrega una condición a la política de confianza del rol que comprueba si se produce un inicio de sesión con MFA. Un usuario que desee asumir el rol debe iniciar sesión con una contraseña temporal de uso único desde un dispositivo MFA configurado. Los usuarios sin autenticación MFA no pueden asumir el rol. Para obtener más información acerca de MFA, consulte [Autenticación multifactor de AWS en IAM](id_credentials_mfa.md)

1. Elija **Siguiente**.

1. IAM incluye una lista de las políticas administradas por AWS y de las políticas administradas por el cliente de cada cuenta. Seleccione la política que desea utilizar como política de permisos o elija **Crear política** para abrir una pestaña nueva del navegador y crear una política nueva desde cero. Para obtener más información, consulte [Crear políticas de IAM](access_policies_create-console.md#access_policies_create-start). Después de crear la política, cierre esa pestaña y vuelva a la pestaña original. Seleccione la casilla situada junto a las políticas de permisos que desea conceder a cualquier persona que asuma el rol. Si lo prefiere, puede optar por no seleccionar ninguna política en este momento y asociar las políticas al rol más adelante. De forma predeterminada, un rol no tiene permisos.

1. (Opcional) Configure un [límite de permisos](access_policies_boundaries.md). Esta es una característica avanzada. 

   Abra la sección **Configurar límite de permisos** y elija **Utilizar un límite de permisos para controlar los permisos que puede tener el rol como máximo**. Seleccione la política que desea utilizar para el límite de permisos.

1. Elija **Siguiente**.

1. Escriba un nombre para el rol en **Nombre de rol**. Los nombres de rol deben ser únicos en su Cuenta de AWS. Cuando se utiliza un nombre de rol en una política o como parte de un ARN, el nombre del rol distingue entre mayúsculas y minúsculas. Cuando los clientes ven un nombre de rol en la consola, por ejemplo, durante el proceso de inicio de sesión, el nombre del rol no distingue entre mayúsculas y minúsculas. Dado que varias entidades pueden hacer referencia al rol, no se puede editar el nombre del rol una vez que se crea.

1. (Opcional) En **Descripción**, ingrese una descripción para el nuevo rol.

1. Elija **Editar** en las secciones **Paso 1: seleccionar entidades de confianza** o **Paso 2: agregar permisos** para editar los casos de uso y los permisos del rol. Volverá a las páginas anteriores para realizar las modificaciones.

1. De manera opcional, agregue metadatos al rol asociando etiquetas como pares de clave-valor. Para obtener más información acerca del uso de etiquetas en IAM, consulte [Etiquetas para recursos de AWS Identity and Access Management](id_tags.md).

1. Revise el rol y, a continuación, seleccione **Crear rol**.
**importante**  
Recuerde que esto es solo la primera mitad de la configuración necesaria. También debe conceder permisos a determinados usuarios de la cuenta de confianza para cambiar al rol en la consola o para asumir el rol mediante programación. Para obtener más información acerca de este paso, consulte [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).

------

## Creación de un rol de IAM (AWS CLI)
<a name="roles-creatingrole-user-cli"></a>

Para crear un rol desde la AWS CLI se deben seguir varios pasos. Si utiliza la consola para crear un rol, muchos de los pasos se realizan automáticamente, pero con la AWS CLI deberá realizar cada paso usted mismo. Debe crear el rol y, a continuación, asignar una política de permisos al rol. Si lo prefiere, también puede configurar el [límite de permisos](access_policies_boundaries.md) para el rol.

**Para crear un rol para el acceso entre cuentas (AWS CLI)**

1. Crear un rol: [aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)

1. Asociar una política de permisos administrada al rol: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html)

    o

   Crear una política de permisos insertada para el rol: [aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

1. (Opcional) Añadir los atributos personalizados al rol asociando etiquetas: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Para obtener más información, consulte [Administrar etiquetas en roles de IAM (AWS CLI o API de AWS)](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. (Opcional) Configurar el [límite de permisos](access_policies_boundaries.md) para el rol: [aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Un límite de permisos controla los permisos que puede tener un rol como máximo. Los límites de permisos son una característica avanzada de AWS.

El siguiente ejemplo muestra los dos primeros pasos, que también son los más comunes, para crear un rol entre cuentas en un entorno sencillo. Este ejemplo permite a cualquier usuario de la cuenta `123456789012` asumir el rol y ver el bucket de `example_bucket` Amazon S3. Este ejemplo también supone que se está utilizando un equipo cliente con Windows y que ya se ha configurado la interfaz de línea de comandos con las credenciales de la cuenta y la región. Para obtener más información, consulte [Configuración de la interfaz de línea de comandos de AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

En este ejemplo, incluya la siguiente política de confianza en el primer comando al crear el rol. Esta política de confianza permite a los usuarios de la cuenta `123456789012` asumir el rol utilizando la operación `AssumeRole`, pero solo si el usuario proporciona la autenticación MFA utilizando los parámetros `SerialNumber` y `TokenCode`. Para obtener más información acerca de MFA, consulte [Autenticación multifactor de AWS en IAM](id_credentials_mfa.md).

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
      {
          "Effect": "Allow",
          "Principal": { "AWS": "arn:aws:iam::123456789012:root" },
          "Action": "sts:AssumeRole",
          "Condition": { "Bool": { "aws:MultiFactorAuthPresent": "true" } }
      }
  ]
}
```

------

**importante**  
Si el elemento `Principal` incluye el ARN de un determinado usuario o rol de IAM, dicho ARN se transforma en un ID exclusivo de entidad principal cuando se guarda la política. Esto ayuda a mitigar el riesgo de que alguien aumente sus permisos eliminando o volviendo a crear el rol o usuario. Normalmente, este ID no se muestra en la consola porque también existe una transformación inversa al ARN cuando se muestra la política de confianza. Sin embargo, si se elimina el rol o el usuario, el ID de entidad principal aparece en la consola porque AWS ya no puede volver a asignarlo a un ARN. Por lo tanto, si elimina y vuelve a crear un usuario o rol al que se hace referencia en un elemento `Principal` de la política de confianza, debe editar el rol para sustituir el ARN.

Cuando utilice el segundo comando, debe asociar una política administrada existente al rol. La siguiente política de permisos permite a cualquiera que asuma el rol realizar únicamente la acción `ListBucket` en el bucket de Amazon S3 `example_bucket`.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
      {
          "Effect": "Allow",
          "Action": "s3:ListBucket",
          "Resource": "arn:aws:s3:::example_bucket"
      }
  ]
}
```

------

Para crear este rol `Test-UserAccess-Role`, primero debe guardar la política de confianza anterior con el nombre `trustpolicyforacct123456789012.json` en la carpeta `policies` del disco duro local `C:`. A continuación, guarde el política de permisos anterior como una política administrada por el cliente en su Cuenta de AWS con el nombre `PolicyForRole`. A continuación, puede utilizar los comandos siguientes para crear el rol y asociarle la política administrada.

```
# Create the role and attach the trust policy file that allows users in the specified account to assume the role.
$ aws iam create-role --role-name Test-UserAccess-Role --assume-role-policy-document file://C:\policies\trustpolicyforacct123456789012.json

# Attach the permissions policy (in this example a managed policy) to the role to specify what it is allowed to do.
$ aws iam attach-role-policy --role-name Test-UserAccess-Role --policy-arn arn:aws:iam::123456789012:policy/PolicyForRole
```

**importante**  
Recuerde que esto es solo la primera mitad de la configuración necesaria. También debe conceder permisos a los usuarios individuales de la cuenta de confianza para cambiar al rol. Para obtener más información acerca de este paso, consulte [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).

Después de crear el rol y concederle permisos para realizar tareas de AWS u obtener acceso a los recursos de AWS, cualquier usuario de la cuenta `123456789012` puede asumir el rol. Para obtener más información, consulte [Cambiar a un rol de IAM (AWS CLI)](id_roles_use_switch-role-cli.md).

## Creación de un rol de IAM (API de AWS)
<a name="roles-creatingrole-user-api"></a>

Para crear un rol desde la API de AWS se deben seguir varios pasos. Si utiliza la consola para crear un rol, muchos de los pasos se realizan automáticamente, pero con la API deberá realizar cada paso usted mismo. Debe crear el rol y, a continuación, asignar una política de permisos al rol. Si lo prefiere, también puede configurar el [límite de permisos](access_policies_boundaries.md) para el rol.

**Para crear un rol en código (API de AWS)**

1. Creación de un rol: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

   Para la política de confianza del rol, puede especificar una ubicación de archivo.

1. Asociar una política de permisos administrada al rol: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

   o

   Crear una política de permisos insertada para el rol: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)
**importante**  
Recuerde que esto es solo la primera mitad de la configuración necesaria. También debe conceder permisos a los usuarios individuales de la cuenta de confianza para cambiar al rol. Para obtener más información acerca de este paso, consulte [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).

1. (Opcional) Añadir los atributos personalizados al usuario asociando etiquetas: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Para obtener más información, consulte [Administrar etiquetas en usuarios de IAM (AWS CLI o API de AWS)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Opcional) Configuración del [límite de permisos](access_policies_boundaries.md) para el rol: [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Un límite de permisos controla los permisos que puede tener un rol como máximo. Los límites de permisos son una característica avanzada de AWS.

Después de crear el rol y concederle permisos para realizar tareas de AWS u obtener acceso a los recursos de AWS, debe conceder permisos a los usuarios de la cuenta para que puedan asumir el rol. Para obtener más información sobre cómo asumir un rol, consulte [Cambiar a un rol de IAM (API de AWS)](id_roles_use_switch-role-api.md).

## Creación de un rol de IAM (AWS CloudFormation)
<a name="roles_creatingrole-user-cloudformation"></a>

Para obtener información acerca de cómo crear un rol de IAM en AWS CloudFormation, consulte la [referencia de recursos y propiedades](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html) y los [ejemplos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#aws-resource-iam-role--examples) en la *Guía del usuario de AWS CloudFormation*.

Para obtener más información acerca de las plantillas de IAM en AWS CloudFormation, consulte [fragmentos de plantilla AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-iam.html) en la *Guía del usuario de AWS CloudFormation*.

# Crear un rol para delegar permisos a un servicio de AWS
<a name="id_roles_create_for-service"></a>

Muchos servicios de AWS requieren que utilice roles para permitir que el servicio obtenga acceso a los recursos de otros servicios en su nombre. Un rol que asume un servicio para realizar acciones en su nombre se denomina [rol de servicio](id_roles.md#iam-term-service-role). Si un rol tiene un fin especializado para un servicio, se categoriza como [rol de servicio vinculado](id_roles.md#iam-term-service-linked-role). Para ver qué servicios son compatibles con el uso de roles vinculados a servicios, o si un servicio admite algún tipo de credenciales temporales, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md). Para obtener información sobre cómo un servicio determinado utiliza los roles, elija el nombre del servicio en la tabla para ver la documentación correspondiente a dicho servicio.

Al configurar el permiso `PassRole`, debe asegurarse de que un usuario no pase un rol en el que el rol tenga más permisos de los que usted desea que tenga el usuario. Por ejemplo, es posible que a Alice no se le permita realizar ninguna acción de Amazon S3. Si Alice pudiera transferir un rol a un servicio que permita acciones de Amazon S3, el servicio podría realizar acciones de Amazon S3 en su nombre al ejecutar el trabajo.

Para obtener información sobre cómo los roles le pueden ayudar a delegar permisos, consulte [Términos y conceptos de roles](id_roles.md#id_roles_terms-and-concepts).

## Permisos del rol de servicio
<a name="id_roles_create_service-permissions"></a>

Debe configurar permisos para permitir a una entidad de IAM (como un usuario, grupo o rol) crear o editar una función de servicio.

**nota**  
El ARN de un rol vinculado a un servicio incluye una entidad principal del servicio, que se indica en las políticas siguientes como `SERVICE-NAME.amazonaws.com`. No intente adivinar la entidad principal del servicio, ya que distingue entre mayúsculas y minúsculas y su formato puede variar para los distintos servicios de AWS. Para ver el elemento principal de un servicio, consulte la documentación correspondiente su rol vinculado a servicio.

**Para permitir a una entidad de IAM cree un rol vinculado a un servicio específico**

Agregue la siguiente política a la entidad de IAM que necesite crear la función de servicio. Esta política le permite crear un rol de servicio para el servicio especificado y con un nombre específico. A continuación, puede asociar políticas administradas o insertadas al rol. 

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:CreateRole",
                "iam:PutRolePolicy"
            ],
            "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME"
        }
    ]
}
```

------

**Cómo permitir a una entidad de IAM crear un rol de servicio**

AWS recomienda permitir solo a los administradores crear cualquier rol de servicio. Una persona con permisos para crear un rol y adjuntar cualquier política puede escalar sus propios permisos. En su lugar, cree una política que les permita crear solo los roles que necesitan o haga que un administrador cree el rol de servicio en su nombre.

Para adjuntar una política que permita a un administrador acceder a toda la Cuenta de AWS, utilice la política administrada [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) de AWS.

**Cómo permitir a una entidad de IAM editar un rol de servicio**

Agregue la siguiente política a la entidad de IAM que necesite editar la función de servicio.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "EditSpecificServiceRole",
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:DeleteRolePolicy",
                "iam:DetachRolePolicy",
                "iam:GetRole",
                "iam:GetRolePolicy",
                "iam:ListAttachedRolePolicies",
                "iam:ListRolePolicies",
                "iam:PutRolePolicy",
                "iam:UpdateRole",
                "iam:UpdateRoleDescription"
            ],
            "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME"
        },
        {
            "Sid": "ViewRolesAndPolicies",
            "Effect": "Allow",
            "Action": [
                "iam:GetPolicy",
                "iam:ListRoles"
            ],
            "Resource": "*"
        }
    ]
}
```

------

**Para permitir a una entidad de IAM eliminar una función de servicio específico**

Agregue la siguiente instrucción a la política de permisos de la entidad de IAM que necesite eliminar la función de servicio especificado.

```
{
    "Effect": "Allow",
    "Action": "iam:DeleteRole",
    "Resource": "arn:aws:iam::*:role/SERVICE-ROLE-NAME"
}
```

**Cómo permitir a una entidad de IAM eliminar cualquier rol de servicio**

AWS recomienda permitir solo a los administradores eliminar cualquier rol de servicio. En su lugar, cree una política que les permita eliminar solo los roles que necesitan o haga que un administrador elimine el rol de servicio en su nombre.

Para adjuntar una política que permita a un administrador acceder a toda la Cuenta de AWS, utilice la política administrada [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) de AWS.

## Creación de un rol para un servicio de AWS (consola)
<a name="roles-creatingrole-service-console"></a>

Puede utilizar la Consola de administración de AWS para crear un rol para un servicio. Algunos servicios admiten más de un rol de servicio. Por lo tanto, recomendamos que consulte la [documentación de AWS](https://docs.aws.amazon.com/) relacionada con su servicio para ver qué caso de uso debe elegir. Puede obtener más información acerca de cómo asignar las políticas de confianza y de permisos necesarias para el rol, para que el servicio pueda asumir el rol en su nombre. Los pasos que puede utilizar para controlar los permisos para el rol pueden variar en función de cómo defina el servicio los casos de uso y de si se crea o no un rol vinculado al servicio.

------
#### [ Console ]

**Cómo crear un rol para un Servicio de AWS (consola de IAM)**

1. Inicie sesión en Consola de administración de AWS y abra la consola IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación de la consola de IAM, seleccione **Roles** y, a continuación, elija **Crear rol**.

1. En **Tipo de entidad de confianza**, elija **Servicio de AWS**.

1. En **Servicio o caso de uso**, seleccione un servicio y, a continuación, el caso de uso. Los casos de uso son definidos por el servicio de modo tal que ya incluyen la política de confianza que el servicio mismo requiere.

1. Elija **Siguiente**.

1. Para las **Políticas de permisos**, las opciones dependen del caso de uso que haya seleccionado:
   + Si el servicio define los permisos para el rol, no puede seleccionar políticas de permisos.
   + Seleccione entre un conjunto limitado de políticas de permisos.
   + Seleccione una de todas las políticas de permisos.
   + No seleccione políticas de permisos en este momento. Después de crear el rol, genere las políticas y luego asócielas al rol.

1. (Opcional) Configure un [límite de permisos](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html). Se trata de una característica avanzada que está disponible para los roles de servicio, pero no para los roles vinculados a servicios.

   1. Abra la sección **Configurar límite de permisos** y, a continuación, elija **Utilizar un límite de permisos para controlar los permisos que puedes tener el rol como máximo**. 

      IAM incluye una lista de las políticas administradas por AWS y de las políticas administradas por el cliente de cada cuenta.

   1. Seleccione la política que desea utilizar para el límite de permisos.

1. Elija **Siguiente**.

1. Para **Nombre del rol**, las opciones varían según el servicio:
   + Si el servicio define el nombre del rol, no podrá editarlo.
   + Si el servicio define un prefijo para el nombre del rol, puede ingresar un sufijo opcional.
   + Si el servicio no define el nombre del rol, podrá nombrarlo usted mismo.
**importante**  
Cuando asigne un nombre a un rol, tenga en cuenta lo siguiente:  
Los nombres de rol deben ser únicos dentro de su Cuenta de AWS, y no se puedesn hacer únicos mediante mayúsculas y minúsculas.  
Por ejemplo, no puedes crear roles denominados tanto **PRODROLE** como **prodrole**. Cuando se utiliza un nombre de rol en una política o como parte de un ARN, el nombre de rol distingue entre mayúsculas y minúsculas, sin embargo, cuando un nombre de rol les aparece a los clientes en la consola, como por ejemplo durante el proceso de inicio de sesión, el nombre de rol no distingue entre mayúsculas y minúsculas.
Dado que otras entidades podrían hacer referencia al rol, no es posible editar el nombre del rol una vez creado.

1. (Opcional) **En Descripción**, ingrese una descripción para el rol.

1. (Opcional) Para editar los casos de uso y los permisos de la función, en las secciones **Paso 1: Seleccionar entidades confiables** o en **Paso 2: Agregar permisos**, elija **Editar**.

1. (Opcional) Para ayudar a identificar, organizar o buscar el rol, agregue etiquetas como pares clave-valor. Para obtener más información sobre el uso de etiquetas en IAM, consulte [Etiquetas para recursos de AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) en la *Guía del usuario de IAM*.

1. Revise el rol y, a continuación, elija **Crear rol**.

------

## Creación de un rol para un servicio (AWS CLI)
<a name="roles-creatingrole-service-cli"></a>

Para crear un rol desde la AWS CLI se deben seguir varios pasos. Si utiliza la consola para crear un rol, muchos de los pasos se realizan automáticamente, pero con la AWS CLI deberá realizar cada paso usted mismo. Debe crear el rol y, a continuación, asignar una política de permisos al rol. Si el servicio con el que está trabajando es Amazon EC2 también deberá crear un perfil de instancia y agregarle el rol. Si lo prefiere, también puede configurar el [límite de permisos](access_policies_boundaries.md) para el rol.

**Para crear un rol para un servicio de AWS desde la AWS CLI**

1. Los siguientes comandos `[create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)` crean un rol llamado *Test-Role* y le asigna una política de confianza:

   `aws iam create-role --role-name Test-Role --assume-role-policy-document file://Test-Role-Trust-Policy.json`

1. Asociar una política de permisos administrada al rol: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html).

   Por ejemplo, el siguiente comando `attach-role-policy` adjunta la política administrada AWS denominada `ReadOnlyAccess` en el rol de IAM denominado `ReadOnlyRole`:

   `aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/ReadOnlyAccess --role-name ReadOnlyRole`

    o

   Crear una política de permisos insertada para el rol: [aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

   Para agregar una política de permisos insertada, consulte el siguiente ejemplo:

    `aws iam put-role-policy --role-name Test-Role --policy-name ExamplePolicy --policy-document file://AdminPolicy.json`

1. (Opcional) Añadir los atributos personalizados al rol asociando etiquetas: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Para obtener más información, consulte [Administrar etiquetas en roles de IAM (AWS CLI o API de AWS)](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. (Opcional) Configurar el [límite de permisos](access_policies_boundaries.md) para el rol: [aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Un límite de permisos controla los permisos que puede tener un rol como máximo. Los límites de permisos son una característica avanzada de AWS.

Si va a utilizar el rol con Amazon EC2 o con otro servicio de AWS que utiliza Amazon EC2, debe almacenar el rol en un perfil de instancias. Un perfil de instancias es un contenedor para un rol que se puede asociar a una instancia de Amazon EC2 cuando se lanza. Un perfil de instancia puede contener un único rol y dicho límite no se puede aumentar. Si crea el rol con la Consola de administración de AWS, el perfil de instancia se crea con el mismo nombre que el rol. Para obtener más información sobre los perfiles de instancia, consulte [Utilizar perfiles de instancia](id_roles_use_switch-role-ec2_instance-profiles.md). Para obtener información sobre cómo inicializar una instancia de EC2 con un rol, consulte [Control del acceso a los recursos de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances) en la *Guía del usuario de Amazon EC2*.

**Para crear un perfil de instancia y almacenar el rol en él (AWS CLI)**

1. Crear un perfil de instancia: [aws iam create-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html)

1. Añadir el rol al perfil de instancia: [aws iam add-role-to-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html)

En el siguiente ejemplo de conjunto de comandos de la AWS CLI, se muestran los dos primeros pasos para crear un rol y asociar permisos. También muestra los dos pasos para crear un perfil de instancia y añadir el rol al perfil. Esta política de confianza de ejemplo permite al servicio Amazon EC2 asumir el rol y ver el bucket de `example_bucket` Amazon S3. El ejemplo también supone que se está utilizando un equipo cliente con Windows y que ya se ha configurado la interfaz de línea de comandos con las credenciales y región de la cuenta. Para obtener más información, consulte [Configuración de la interfaz de línea de comandos de AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

En este ejemplo, incluya la siguiente política de confianza en el primer comando al crear el rol. Esta política de confianza permite que el servicio Amazon EC2 asuma el rol. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Principal": {"Service": "ec2.amazonaws.com"},
    "Action": "sts:AssumeRole"
  }
}
```

------

Cuando utilice el segundo comando, debe asociar una política de permisos al rol. La siguiente política de permisos de ejemplo permite al rol realizar únicamente la acción `ListBucket` en el bucket de Amazon S3 `example_bucket`.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:ListBucket",
    "Resource": "arn:aws:s3:::example_bucket"
  }
}
```

------

Para crear el rol `Test-Role-for-EC2`, primero debe guardar la política de confianza anterior con el nombre `trustpolicyforec2.json` y la política de permisos anterior con el nombre `permissionspolicyforec2.json` en el directorio `policies` del disco duro local `C:`. A continuación, puede utilizar los siguientes comandos para crear el rol, asociar la política, crear el perfil de instancia y añadir el rol al perfil de instancia.

```
# Create the role and attach the trust policy that allows EC2 to assume this role.
$ aws iam create-role --role-name Test-Role-for-EC2 --assume-role-policy-document file://C:\policies\trustpolicyforec2.json

# Embed the permissions policy (in this example an inline policy) to the role to specify what it is allowed to do.
$ aws iam put-role-policy --role-name Test-Role-for-EC2 --policy-name Permissions-Policy-For-Ec2 --policy-document file://C:\policies\permissionspolicyforec2.json

# Create the instance profile required by EC2 to contain the role
$ aws iam create-instance-profile --instance-profile-name EC2-ListBucket-S3

# Finally, add the role to the instance profile
$ aws iam add-role-to-instance-profile --instance-profile-name EC2-ListBucket-S3 --role-name Test-Role-for-EC2
```

Al lanzar la instancia EC2, especifique el nombre de perfil de instancia en la página **Configurar detalles de la instancia** si utiliza la consola de AWS. Si utiliza el comando de la CLI `aws ec2 run-instances`, especifique el parámetro `--iam-instance-profile`.

## Creación de un rol para un servicio (API de AWS)
<a name="roles-creatingrole-service-api"></a>

Para crear un rol desde la API de AWS se deben seguir varios pasos. Si utiliza la consola para crear un rol, muchos de los pasos se realizan automáticamente, pero con la API deberá realizar cada paso usted mismo. Debe crear el rol y, a continuación, asignar una política de permisos al rol. Si el servicio con el que está trabajando es Amazon EC2 también deberá crear un perfil de instancia y agregarle el rol. Si lo prefiere, también puede configurar el [límite de permisos](access_policies_boundaries.md) para el rol.

**Para crear un rol para un servicio de AWS (API de AWS)**

1. Creación de un rol: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

   Para la política de confianza del rol, puede especificar una ubicación de archivo.

1. Asociar una política de permisos administrada al rol: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

    o

   Crear una política de permisos insertada para el rol: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

1. (Opcional) Añadir los atributos personalizados al usuario asociando etiquetas: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Para obtener más información, consulte [Administrar etiquetas en usuarios de IAM (AWS CLI o API de AWS)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Opcional) Configuración del [límite de permisos](access_policies_boundaries.md) para el rol: [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Un límite de permisos controla los permisos que puede tener un rol como máximo. Los límites de permisos son una característica avanzada de AWS.

Si va a utilizar el rol con Amazon EC2 o con otro servicio de AWS que utiliza Amazon EC2, debe almacenar el rol en un perfil de instancias. Un perfil de instancia es un contenedor para un rol. Cada perfil de instancia solo puede contener un único rol y dicho límite no se puede superar. Si crea el rol en la Consola de administración de AWS, el perfil de instancia se crea con el mismo nombre que el rol. Para obtener más información sobre los perfiles de instancia, consulte [Utilizar perfiles de instancia](id_roles_use_switch-role-ec2_instance-profiles.md). Para obtener información sobre cómo inicializar una instancia de Amazon EC2 con un rol, consulte [Control del acceso a los recursos de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances) en la *Guía del usuario de Amazon EC2*. 

**Para crear un perfil de instancia y almacenar el rol en él (API de AWS)**

1. Crear un perfil de instancia: [CreateInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html)

1. Añadir el rol al perfil de instancia: [AddRoleToInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html)

# Creación de un rol vinculado al servicio
<a name="id_roles_create-service-linked-role"></a>

Un rol vinculado a un servicio es un tipo único de rol de IAM que está vinculado directamente a un servicio de AWS. Los roles vinculados a servicios son predefinidos por el servicio e incluyen todos los permisos que el servicio requiere para llamar a otros servicios de AWS en su nombre. El servicio vinculado también define cómo crear, modificar y eliminar un rol vinculado a un servicio. Un servicio podría crear el rol automáticamente o eliminarlo. Podría permitirle crear, modificar o eliminar el rol como parte de un asistente o proceso del servicio. También podría exigir que utilice IAM para crear o eliminar el rol. Independientemente del método, los roles vinculados a servicios simplifican la configuración de un servicio porque ya no tendrá que agregar manualmente los permisos necesarios para que el servicio complete acciones en su nombre.

**nota**  
Recuerde que los roles de servicio son diferentes a los roles vinculados a servicios. 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*. 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. 

El servicio vinculado define los permisos de los roles vinculados con el servicio mismo y, a menos que esté definido de otra manera, solo ese servicio puede asumir los roles. Los permisos definidos incluyen las políticas de confianza y de permisos, y que la política de permisos no se pueda asociar a ninguna otra entidad de IAM.

Antes de eliminar las funciones, debe borrar antes sus recursos relacionados. Esto ayuda a impedir que elimine accidentalmente el permiso para acceder a los recursos. 

**sugerencia**  
Para obtener información sobre los servicios que admiten el uso de roles vinculados a servicios, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md) y busque los servicios que tengan **Yes **en la columna **Service-Linked Role**. Elija una opción **Sí** con un enlace para ver la documentación acerca del rol vinculado al servicio en cuestión.

## Permisos de roles vinculados a servicios
<a name="service-linked-role-permissions"></a>

Debe configurar permisos para que una entidad de IAM (usuario, grupo o función) permita al usuario o rol crear o editar el rol vinculado al servicio.

**nota**  
El ARN de un rol vinculado a un servicio incluye una entidad principal del servicio, que se indica en las políticas siguientes como `SERVICE-NAME.amazonaws.com`. No intente adivinar la entidad principal del servicio, ya que distingue entre mayúsculas y minúsculas y su formato puede variar para los distintos servicios de AWS. Para ver el elemento principal de un servicio, consulte la documentación correspondiente su rol vinculado a servicio.

**Para permitir a una entidad de IAM que cree un rol vinculado a un servicio específico**

Agregue la siguiente política a la entidad de IAM que necesite crear el rol vinculado con un servicio.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "iam:CreateServiceLinkedRole",
            "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*",
            "Condition": {"StringLike": {"iam:AWSServiceName": "SERVICE-NAME.amazonaws.com"}}
        },
        {
            "Effect": "Allow",
            "Action": [
                "iam:AttachRolePolicy",
                "iam:PutRolePolicy"
            ],
            "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*"
        }
    ]
}
```

------

**Para permitir a una entidad de IAM crear un rol vinculado a cualquier servicio**

Agregue la siguiente instrucción a la política de permisos de la entidad de IAM que necesite crear un rol vinculado con un servicio o cualquier función de servicio que incluya las políticas necesarias. Esta instrucción de política no permite la entidad IAM adjunte una política al rol.

```
{
    "Effect": "Allow",
    "Action": "iam:CreateServiceLinkedRole",
    "Resource": "arn:aws:iam::*:role/aws-service-role/*"
}
```

**Para permitir a una entidad IAM editar la descripción de cualquier función de servicio de servicio**

Agregue la siguiente instrucción a la política de permisos de la entidad de IAM que necesite editar la descripción de un rol vinculado con un servicio o cualquier función de servicio.

```
{
    "Effect": "Allow",
    "Action": "iam:UpdateRoleDescription",
    "Resource": "arn:aws:iam::*:role/aws-service-role/*"
}
```

**Para permitir a una entidad de IAM eliminar un rol vinculado a un servicio específico**

agregue la siguiente instrucción a la política de permisos de la entidad de IAM entidad que necesita eliminar el rol vinculado con el servicio.

```
{
    "Effect": "Allow",
    "Action": [
        "iam:DeleteServiceLinkedRole",
        "iam:GetServiceLinkedRoleDeletionStatus"
    ],
    "Resource": "arn:aws:iam::*:role/aws-service-role/SERVICE-NAME.amazonaws.com/SERVICE-LINKED-ROLE-NAME-PREFIX*"
}
```

**Para permitir a una entidad de IAM eliminar un rol vinculado a cualquier servicio**

Agregue la siguiente instrucción a la política de permisos de la entidad de IAM que necesita eliminar un rol vinculado con un servicio pero no una función de servicio.

```
{
    "Effect": "Allow",
    "Action": [
        "iam:DeleteServiceLinkedRole",
        "iam:GetServiceLinkedRoleDeletionStatus"
    ],
    "Resource": "arn:aws:iam::*:role/aws-service-role/*"
}
```

**Para permitir que una entidad de IAM pase un rol existente al servicio**

Algunos servicios de AWS le permiten pasar un rol existente en lugar de crear uno nuevo vinculado al servicio. Para ello, un usuario debe tener permisos para *pasar el rol* al servicio. Agregue la siguiente instrucción a la política de permisos de la entidad de IAM que necesite pasar el rol. Esta instrucción de la política también permite a la entidad ver la lista de roles entre los que elegir el que se debe pasar. Para obtener más información, consulte [Conceder permisos a un usuario para transferir un rol a un servicio de AWS](id_roles_use_passrole.md).

```
{
  "Sid": "PolicyStatementToAllowUserToListRoles",
  "Effect": "Allow",
  "Action": ["iam:ListRoles"],
  "Resource": "*"
},
{
  "Sid": "PolicyStatementToAllowUserToPassOneSpecificRole",
  "Effect": "Allow",
  "Action": [ "iam:PassRole" ],
  "Resource": "arn:aws:iam::account-id:role/my-role-for-XYZ"
}
```

## Permisos indirectos con funciones vinculadas al servicio
<a name="create-service-linked-role-permissions-transfer"></a>

Los permisos concedidos por un rol vinculado a un servicio se pueden transferir indirectamente a otros usuarios y roles. Cuando un rol vinculado al servicio es utilizado por un servicio de AWS, ese rol puede usar sus propios permisos para llamar a otros servicios de AWS. Esto significa que los usuarios y los roles con permisos para llamar a un servicio que usa un rol vinculado al servicio pueden tener acceso indirecto a los servicios a los que puede acceder dicho rol vinculado al servicio.

Por ejemplo, al crear una instancia de base de datos de Amazon RDS, se crea automáticamente [un rol vinculado a un servicio para RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAM.ServiceLinkedRoles.html) si aún no existe ninguno. Este rol vinculado al servicio permite a RDS llamar a Amazon EC2, Amazon SNS, Amazon CloudWatch Logs y Amazon Kinesis en su nombre siempre que edite la instancia de base de datos. Si se permite que los usuarios y los roles de su cuenta modifiquen o creen bases de datos de RDS, es posible que puedan interactuar indirectamente con los registros de Amazon EC2, Amazon SNS, los registros de Amazon CloudWatch y los recursos de Amazon Kinesis llamando a RDS, ya que RDS utilizaría su función vinculada al servicio para acceder a esos recursos.

### Métodos para crear un rol vinculado a un servicio
<a name="create-service-linked-role"></a>

El método que se utiliza para crear roles vinculados a servicios depende del servicio. En algunos casos, no es necesario crear manualmente roles vinculados a servicios. Por ejemplo, al finalizar una acción específica (por ejemplo, la creación de un recurso) en el servicio, este puede crear el rol vinculado al servicio en su nombre. Si utilizaba un servicio antes de que comenzara a admitir roles vinculados a servicios, el servicio podría crear automáticamente el rol en la cuenta. Para obtener más información, consulte [Un nuevo rol ha aparecido en la cuenta de AWS](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared).

En otros casos, el servicio podría admitir la creación manual de un rol vinculado al servicio mismo mediante su consola, la API o la CLI. Para obtener información sobre los servicios que admiten el uso de roles vinculados a servicios, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md) y busque los servicios que tengan **Yes **en la columna **Service-Linked Role**. Para saber si el servicio admite la creación de roles vinculados al servicio mismo, haga clic en el enlace **Sí** para consultar la documentación relacionada con los roles vinculados a dicho servicio.

Si el servicio no admite la creación de roles, puede utilizar IAM para crear el rol vinculado al servicio.

**importante**  
Los roles vinculados a servicios se contabilizan como [roles de IAM en una Cuenta de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html#reference_iam-quotas-entities) pero, si ha alcanzado el límite de servicio, igualmente puede crear roles vinculados a servicios en su cuenta. Los roles vinculados a servicios son los únicos que pueden superar el límite.

### Creación de un rol vinculado a un servicio (consola)
<a name="create-service-linked-role-iam-console"></a>

Antes de crear un rol vinculado a un servicio en IAM, averigüe primero si el servicio vinculado crea automáticamente roles vinculados a servicios, además aprenderá si es posible crearlo desde la consola del servicio, la API o la CLI.<a name="create-service-linked-role-iam-console"></a>

**Para crear un rol vinculado a un servicio (consola)**

1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación de la consola de IAM, elija **Roles**. A continuación, elija **Create role** (Crear rol).

1. Elija el tipo de rol **Servicio de AWS**.

1. Elija el caso de uso para su servicio. Los casos de uso son definidos por el servicio de modo tal que ya incluyen la política de confianza exigida por el servicio mismo. A continuación, elija **Siguiente**.

1. Elija una o varias políticas de permisos para asociarlas al rol. En función del caso de uso seleccionado, el servicio podría realizar cualquiera de las siguientes acciones:
   + Definir los permisos que utiliza el rol.
   + Permitirle elegir permisos de un conjunto limitado.
   + Permitirle elegir cualquier permiso.
   + Permitirle no seleccionar ninguna política en ese momento, crear las políticas más adelante y, a continuación, asociarlas al rol.

   Seleccione la casilla situada junto a la política que asigna los permisos que desea que tenga el rol y, a continuación, elija **Siguiente**. 
**nota**  
Los permisos que especifique están disponibles para cualquier entidad que utilice el rol. De forma predeterminada, un rol no tiene permisos.

1. En **Role Name (Nombre del rol)**, el servicio define el grado de personalización del nombre del rol. Si el servicio define el nombre del rol, esta opción no es editable. En otros casos, el servicio puede definir un prefijo para el rol y permitirle ingresar un sufijo opcional.

   De ser posible, ingrese un sufijo de nombre de rol para agregarlo al nombre predeterminado. Este sufijo le permite identificar el propósito de este rol. Los nombres de rol deben ser únicos en su cuenta de AWS. No distinguen entre mayúsculas y minúsculas. Por ejemplo, no puede crear funciones denominado tanto **<service-linked-role-name>\$1SAMPLE** como **<service-linked-role-name>\$1sample**. Dado que varias entidades pueden hacer referencia al rol, no puede editar el nombre del rol después de crearlo.

1. (Opcional) En **Description** (Descripción), edite la descripción del nuevo rol vinculado al servicio.

1. No puede asociar etiquetas a roles vinculados a servicios durante la creación. Para obtener más información acerca del uso de etiquetas en IAM, consulte [Etiquetas para recursos de AWS Identity and Access Management](id_tags.md).

1. Revise el rol y, a continuación, seleccione **Crear rol**.

### Crear una función vinculada a un servicio (AWS CLI)
<a name="create-service-linked-role-iam-cli"></a>

Antes de crear un rol vinculado a un servicio en IAM, averigüe primero si el servicio vinculado crea automáticamente roles vinculados a servicios y si no es posible crearlo desde la CLI del servicio. Si la CLI del servicio no es compatible, puede utilizar comandos de IAM para crear un rol vinculado al servicio con la política de confianza y las políticas insertadas que el servicio necesita para asumir el rol.

**Para crear un rol vinculado a un servicio (AWS CLI)**

Use el siguiente comando:

```
aws iam [create-service-linked-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-service-linked-role.html) --aws-service-name SERVICE-NAME.amazonaws.com
```

### Crear un rol vinculado a un servicio (API de AWS)
<a name="create-service-linked-role-iam-api"></a>

Antes de crear un rol vinculado a un servicio en IAM, averigüe primero si el servicio vinculado crea automáticamente roles vinculados a servicios y si no es posible crearlo desde la API del servicio. Si la API del servicio no es compatible, puede utilizar la API de AWS para crear un rol vinculado al servicio con la política de confianza y las políticas insertadas que el servicio necesita para asumir el rol.

**Para crear un rol vinculado a un servicio (API de AWS)**

Utilice la llamada a la API [CreateServiceLinkedRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceLinkedRole.html). En la solicitud, especifique el nombre del servicio de `SERVICE_NAME_URL.amazonaws.com`. 

Por ejemplo, para crear el rol vinculado al servicio **Robots de Lex**, utilice `lex.amazonaws.com`.

# Creación de un rol para un proveedor de identidad externo
<a name="id_roles_create_for-idp"></a>

Puede utilizar proveedores de identidad en lugar de crear usuarios de IAM en una Cuenta de AWS. Con un proveedor de identidad (IdP), puede administrar las identidades de usuario fuera de AWS y conceder permisos a estas identidades de usuarios externos para que tengan acceso a los recursos de AWS de su cuenta. Para obtener más información acerca de la identidad federada y los proveedores de identidad, consulte [Proveedores de identidades y federación en AWS](id_roles_providers.md).

## Creación de un rol para entidades principales federadas de OIDC y SAML (consola)
<a name="roles-creatingrole-federated-users-console"></a>

Los procedimientos para crear un rol dependen del proveedor externo que elija.
+ Para conexiones OpenID Connect (OIDC), consulte [Creación de un rol para una federación de OpenID Connect (consola)](id_roles_create_for-idp_oidc.md).
+ Para SAML 2.0, consulte [Creación de un rol para una federación SAML 2.0 (consola)](id_roles_create_for-idp_saml.md).

## Creación de un rol para acceso federado (AWS CLI)
<a name="roles-creatingrole-identityprovider-cli"></a>

Los pasos que ha de seguir para crear un rol para los proveedores de identidad compatibles (OIDC o SAML) desde la AWS CLI son idénticos. La diferencia está en el contenido de la política de confianza que crea en los pasos de requisitos previos. Empiece siguiendo los pasos de la sección **Requisitos previos** para el tipo de proveedor que utilice:
+ Para un proveedor OIDC, consulte [Requisitos previos para crear un rol para OIDC](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites).
+ Para un proveedor SAML, consulte [Requisitos previos para crear un rol para SAML](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites).

Para crear un rol desde la AWS CLI se deben seguir varios pasos. Si utiliza la consola para crear un rol, muchos de los pasos se realizan automáticamente, pero con la AWS CLI deberá realizar cada paso usted mismo. Debe crear el rol y, a continuación, asignar una política de permisos al rol. Si lo prefiere, también puede configurar el [límite de permisos](access_policies_boundaries.md) para el rol.

**Para crear un rol (AWS CLI)**

1. Crear un rol: [aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)

1. Asociar una política de permisos al rol: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html)

    o

   Crear una política de permisos insertada para el rol: [aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

1. (Opcional) Añadir los atributos personalizados al rol asociando etiquetas: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Para obtener más información, consulte [Administrar etiquetas en roles de IAM (AWS CLI o API de AWS)](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. (Opcional) Configurar el [límite de permisos](access_policies_boundaries.md) para el rol: [aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Un límite de permisos controla los permisos que puede tener un rol como máximo. Los límites de permisos son una característica avanzada de AWS.

El siguiente ejemplo muestra los dos primeros pasos, que también son los más comunes, para crear un rol de proveedor de identidad en un entorno sencillo. Este ejemplo permite a cualquier usuario de la cuenta `123456789012` asumir el rol y ver el bucket de `example_bucket` Amazon S3. En el ejemplo, también se presupone que está ejecutando la AWS CLI en un equipo con Windows y que ya ha configurado la AWS CLI con sus credenciales. Para obtener más información, consulte [Configuración de la AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

En el ejemplo siguiente, la política de confianza está diseñada para una aplicación móvil si el usuario inicia sesión mediante Amazon Cognito. En este ejemplo, *us-east:12345678-ffff-ffff-ffff-123456* representa el ID del grupo de identidades asignado por Amazon Cognito.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Sid": "RoleForCognito",
        "Effect": "Allow",
        "Principal": {"Federated": "cognito-identity.amazonaws.com"},
        "Action": "sts:AssumeRoleWithWebIdentity",
        "Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}
    }
}
```

------

La siguiente política de permisos permite a cualquiera que asuma el rol realizar únicamente la acción `ListBucket` en el bucket de Amazon S3 `example_bucket`.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:ListBucket",
    "Resource": "arn:aws:s3:::example_bucket"
  }
}
```

------

Para crear el rol `Test-Cognito-Role`, primero debe guardar la política de confianza anterior con el nombre `trustpolicyforcognitofederation.json` y la política de permisos anterior con el nombre `permspolicyforcognitofederation.json` en la carpeta `policies` del disco duro local `C:`. A continuación, puede utilizar los comandos siguientes para crear el rol y asociarle la política insertada.

```
# Create the role and attach the trust policy that enables users in an account to assume the role.
$ aws iam create-role --role-name Test-Cognito-Role --assume-role-policy-document file://C:\policies\trustpolicyforcognitofederation.json

# Attach the permissions policy to the role to specify what it is allowed to do.
aws iam put-role-policy --role-name Test-Cognito-Role --policy-name Perms-Policy-For-CognitoFederation --policy-document file://C:\policies\permspolicyforcognitofederation.json
```

## Creación de un rol para acceso federado (API de AWS)
<a name="roles-creatingrole-identityprovider-api"></a>

Los pasos que ha de seguir para crear un rol para los proveedores de identidad compatibles (OIDC o SAML) desde la AWS CLI son idénticos. La diferencia está en el contenido de la política de confianza que crea en los pasos de requisitos previos. Empiece siguiendo los pasos de la sección **Requisitos previos** para el tipo de proveedor que utilice:
+ Para un proveedor OIDC, consulte [Requisitos previos para crear un rol para OIDC](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites).
+ Para un proveedor SAML, consulte [Requisitos previos para crear un rol para SAML](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites).

**Para crear un rol (API AWS)**

1. Creación de un rol: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

1. Asociar una política de permisos al rol: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

    o

   Crear una política de permisos insertada para el rol: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

1. (Opcional) Añadir los atributos personalizados al usuario asociando etiquetas: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Para obtener más información, consulte [Administrar etiquetas en usuarios de IAM (AWS CLI o API de AWS)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Opcional) Configuración del [límite de permisos](access_policies_boundaries.md) para el rol: [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Un límite de permisos controla los permisos que puede tener un rol como máximo. Los límites de permisos son una característica avanzada de AWS.

# Creación de un rol para una federación de OpenID Connect (consola)
<a name="id_roles_create_for-idp_oidc"></a>

Puede utilizar proveedores de identidad federados de OpenID Connect (OIDC) en lugar de crear usuarios de AWS Identity and Access Management en la Cuenta de AWS. Con un proveedor de identidad (IdP), puede administrar las identidades de usuario fuera de AWS y conceder permisos a estas identidades de usuarios externos para que tengan acceso a los recursos de AWS de su cuenta. Para obtener más información acerca de la federación y los IdP, consulte [Proveedores de identidades y federación en AWS](id_roles_providers.md).

## Requisitos previos para crear un rol para OIDC
<a name="idp_oidc_Prerequisites"></a>

Para poder crear un rol para federación de OIDC, antes debe completar los siguientes pasos de los requisitos previos.<a name="oidc-prereqs"></a>

**Preparativos para crear un rol para la federación de OIDC**

1. Regístrese con uno o más servicios que ofrezcan identidad de OIDC federada. Si está creando una aplicación que necesita obtener acceso a los recursos de AWS, también deberá configurarla con la información del proveedor. Cuando lo haga, el proveedor le proporcionará un ID de aplicación o de público exclusivo de la aplicación. (Cada proveedor utiliza una terminología diferente para este proceso. En esta guía se utiliza el término *configurar* para el proceso de identificación de su aplicación con el proveedor). Puede configurar varias aplicaciones con cada proveedor o varios proveedores con una sola aplicación. Consulte la información sobre el uso de los proveedores de identidades de la siguiente manera:
   + [Registro con Amazon Developer Center](https://login.amazon.com/)
   + [Añada inicio de sesión con Facebook a su aplicación o sitio web](https://developers.facebook.com/docs/facebook-login/v2.1) en el sitio de desarrolladores de Facebook.
   + [Uso de OAuth 2.0 para iniciar sesión (OpenID Connect)](https://developers.google.com/accounts/docs/OAuth2Login) en el sitio de desarrolladores de Google.

1. <a name="idpoidcstep2"></a>Después de recibir la información necesaria del IdP, cree un IdP en IAM. Para obtener más información, consulte [Crear un proveedor de identidad de IAM OpenID Connect (OIDC)](id_roles_providers_create_oidc.md).
**importante**  
Si utiliza un IdP de OIDC de Google, Facebook o Amazon Cognito, no cree un IdP de IAM independiente en el Consola de administración de AWS. Estos proveedores de identidades de OIDC ya están integrados en AWS y están disponibles para su uso. Omita este paso y cree nuevos roles con su IdP en el siguiente paso.

1. Prepare las políticas para el rol que asumirán los usuarios autenticados mediante el proveedor de identidades. Como sucede con cualquier otro rol, un rol para una aplicación móvil incluye dos políticas. Una es la política de confianza que especifica quién puede asumir el rol. La otra es la política de permisos que especifica las acciones y los recursos de AWS a los que la aplicación móvil puede obtener acceso o se le deniega.

   En el caso de IdP web, le recomendamos utilizar [Amazon Cognito](https://aws.amazon.com/cognito/) para administrar las identidades. En este caso, utilice una política de confianza similar a la de este ejemplo.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Principal": {"Federated": "cognito-identity.amazonaws.com"},
           "Action": "sts:AssumeRoleWithWebIdentity",
           "Condition": {
               "StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east-2:12345678-abcd-abcd-abcd-123456"},
               "ForAnyValue:StringLike": {"cognito-identity.amazonaws.com:amr": "unauthenticated"}
           }
       }
   }
   ```

------

   Reemplace `us-east-2:12345678-abcd-abcd-abcd-123456` por el ID del grupo de identidades que Amazon Cognito le ha asignado.

   Si configura de manera manual un proveedor de identidad OIDC (IdP), al crear la política de confianza debe utilizar tres valores que garanticen que únicamente su aplicación puede asumir el rol:
   + En el elemento `Action`, utilice la acción `sts:AssumeRoleWithWebIdentity`.
   + En el elemento `Principal`, utilice la cadena `{"Federated":providerUrl/providerArn}`.
     + En el caso de algunos IdP de OIDC conocidos, el `providerUrl` es una URL. En los siguientes ejemplos se incluyen métodos que permiten especificar la entidad principal para algunos de estos proveedores de identidad:

       `"Principal":{"Federated":"cognito-identity.amazonaws.com"}`

       `"Principal":{"Federated":"www.amazon.com"}`

       `"Principal":{"Federated":"graph.facebook.com"}`

       `"Principal":{"Federated":"accounts.google.com"}`
     + Para los demás proveedores de OIDC, utilice el nombre de recurso de Amazon (ARN) del proveedor de identidades de OIDC que ha creado en [Step 2](#idpoidcstep2), como se muestra en el siguiente ejemplo:

       `"Principal":{"Federated":"arn:aws:iam::123456789012:oidc-provider/server.example.com"}`
   + En el elemento `Condition`, utilice una condición `StringEquals` para limitar los permisos. Pruebe el ID del grupo de identidades (para Amazon Cognito) o el ID de aplicación (para otros proveedores). El ID del grupo de identidades debe coincidir con el ID de la aplicación que ha recibido al configurarla con el IdP. Esta coincidencia entre los ID asegura que la solicitud provenga de su aplicación.
**nota**  
Los roles de IAM para los grupos de identidades de Amazon Cognito confían en que la entidad principal `cognito-identity.amazonaws.com` del servicio asuma el rol. Los roles de este tipo deben contener al menos una clave de condición para limitar el número de entidades principales que pueden asumir el rol.  
Se aplican consideraciones adicionales a los grupos de identidades de Amazon Cognito que asumen [roles de IAM entre cuentas](access_policies-cross-account-resource-access.md). Las políticas de confianza de estos roles deben aceptar la entidad principal del servicio `cognito-identity.amazonaws.com` y deben contener la clave de condición `aud` para restringir la asunción de roles a los usuarios de los grupos de identidades previstos. Una política que confíe en los grupos de identidades de Amazon Cognito sin esta condición crea el riesgo de que un usuario de un grupo de identidades no deseado asuma el rol. Para obtener más información, consulte [Políticas de confianza para roles de IAM en la autenticación básica (clásica)](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#trust-policies) en la *Guía para desarrolladores de Amazon Cognito*.

     Cree un elemento de condición similar a uno de los siguientes ejemplos, en función del IdP que esté utilizando: 

     `"Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}`

     `"Condition": {"StringEquals": {"www.amazon.com:app_id": "amzn1.application-oa2-123456"}}`

     `"Condition": {"StringEquals": {"graph.facebook.com:app_id": "111222333444555"}}`

     `"Condition": {"StringEquals": {"accounts.google.com:aud": "66677788899900pro0"}}`

     En el caso de los proveedores OIDC, utilice la dirección URL completa del proveedor de identidad OIDC con la clave de contexto `aud`, como se muestra en el siguiente ejemplo: 

     `"Condition": {"StringEquals": {"server.example.com:aud": "appid_from_oidc_idp"}}`
**nota**  
Observe que los valores de la entidad principal de la política de confianza del rol son específicos de un IdP. Un rol para OIDC puede especificar solo una entidad principal. Por lo tanto, si la aplicación móvil permite a los usuarios iniciar sesión desde varios IdP, debe crear un rol independiente para cada IdP que desee admitir. Cree políticas de confianza independientes para cada IdP.

   Si un usuario utiliza una aplicación móvil para iniciar sesión desde Inicio de sesión con Amazon, se aplicará el siguiente ejemplo de política de confianza. En el ejemplo, *amzn1.application-oa2-123456* representa el ID de la aplicación que Amazon asignó cuando configuró la aplicación con Login with Amazon.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForLoginWithAmazon",
             "Effect": "Allow",
             "Principal": {"Federated": "www.amazon.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"www.amazon.com:app_id": "amzn1.application-oa2-123456"}}
         }]
     }
   ```

------

   Si un usuario utiliza una aplicación móvil para iniciar sesión desde Facebook, se aplicará el siguiente ejemplo de política de confianza. En este ejemplo, *111222333444555* representa el ID de la aplicación asignado por Facebook.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForFacebook",
             "Effect": "Allow",
             "Principal": {"Federated": "graph.facebook.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"graph.facebook.com:app_id": "111222333444555"}}
         }]
     }
   ```

------

   Si un usuario utiliza una aplicación móvil para iniciar sesión desde Google, se aplicará el siguiente ejemplo de política de confianza. En este ejemplo, *666777888999000* representa el ID de la aplicación asignado por Google.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForGoogle",
             "Effect": "Allow",
             "Principal": {"Federated": "accounts.google.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"accounts.google.com:aud": "666777888999000"}}
         }]
     }
   ```

------

   Si un usuario utiliza una aplicación móvil para iniciar sesión desde Amazon Cognito, se aplicará el siguiente ejemplo de política de confianza. En este ejemplo, *us-east:12345678-ffff-ffff-ffff-123456* representa el ID del grupo de identidades asignado por Amazon Cognito.

------
#### [ JSON ]

****  

   ```
   {
         "Version":"2012-10-17",		 	 	 
         "Statement": [{
             "Sid": "RoleForCognito",
             "Effect": "Allow",
             "Principal": {"Federated": "cognito-identity.amazonaws.com"},
             "Action": "sts:AssumeRoleWithWebIdentity",
             "Condition": {"StringEquals": {"cognito-identity.amazonaws.com:aud": "us-east:12345678-ffff-ffff-ffff-123456"}}
         }]
     }
   ```

------

## Creación de un rol para OIDC
<a name="idp_oidc_Create"></a>

Después de completar los requisitos previos, puede crear el rol en IAM. Para los proveedores de identidades compartidos de OpenID Connect (OIDC) reconocidos, IAM exige la evaluación explícita de ciertas declaraciones en los JSON Web Tokens (JWT), lo que se conoce como *controles del proveedor de identidades*. Para obtener más información sobre qué proveedores de identidades OIDC tienen *controles de proveedor de identidades*, consulte [Controles del proveedor de identidad para proveedores compartidos de OIDC](id_roles_providers_oidc_secure-by-default.md).

En el siguiente procedimiento se describe cómo crear el rol de federación de OIDC en la Consola de administración de AWS. Para crear un rol desde la AWS CLI o la API de AWS, consulte los procedimientos en [Creación de un rol para un proveedor de identidad externo](id_roles_create_for-idp.md).

**importante**  
Si utiliza Amazon Cognito, debe utilizar la consola de Amazon Cognito para configurar los roles. De lo contrario, utilice la consola de IAM para crear un rol para la federación de OIDC.

**Cómo crear un rol de IAM para una federación de OIDC**

1. Inicie sesión en Consola de administración de AWS y abra la consola IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación, seleccione **Roles** y, a continuación, seleccione **Crear rol**.

1. Elija **Identidad web** como tipo de entidad de confianza y seleccione **Siguiente**.

1. En **Proveedor de identidad**, elija el IdP para el rol: 
   + Si está creando un rol para un IdP web individual, elija **Inicio de sesión con Amazon**, **Facebook** o **Google**. 
**nota**  
Debe crear un rol independiente para cada IdP al que desee admitir.
   + Si está creando un rol de situación avanzada para Amazon Cognito, elija **Amazon Cognito**. 
**nota**  
Solo deberá crear manualmente un rol para utilizarlo con Amazon Cognito si está trabajando en una situación avanzada. En caso contrario, Amazon Cognito puede crear roles de forma automática. Para obtener más información sobre Amazon Cognito, consulte [Proveedores de identidades externos de grupos de identidad (identidades federadas)](https://docs.aws.amazon.com/cognito/latest/developerguide/external-identity-providers.html) en la *Guía para desarrolladores de Amazon Cognito*. 
   + Si quiere crear un rol para GitHub Actions, primero debe agregar el proveedor OIDC de GitHub a IAM. Después de agregar el proveedor OIDC de GitHub a IAM, elija **token.actions.githubusercontent.com**. 
**nota**  
Para obtener información acerca de cómo configurar AWS para confiar en el proveedor de OIDC de GitHub como una identidad federada, consulte [GitHub Docs - Configuring OpenID Connect in Amazon Web Services](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services). Para obtener información sobre las mejores prácticas para limitar el acceso a los roles asociados al IdP de IAM para GitHub, consulte [Configuración de un rol para el proveedor de identidades de OIDC de GitHub](#idp_oidc_Create_GitHub) en esta página.
   + Si quiere crear un rol para HashiCorp Cloud Platform (HCP) Terraform, primero debe añadir el proveedor de OIDC de Terraform a IAM. Después de añadir el proveedor de OIDC de Terraform a IAM, elija **app.terraform.io**. 
**importante**  
Los roles de IAM para el proveedor de OIDC de HashiCorp Cloud Platform (HCP) Terraform debe evaluar la clave de condición de IAM, `app.terraform.io:sub`, en la política de confianza de funciones. Esta clave de condición limita los roles que las organizaciones, los proyectos, los espacios de trabajo o las fases de ejecución de Terraform de HCP pueden asumir. Sin esta clave de condición, su política de confianza permite que personas ajenas a la organización accedan a su rol y a sus recursos de AWS, lo que no se ajusta al principio del privilegio mínimo.   
Si establece o modifica una política de confianza de roles para un rol asociado al proveedor de OIDC de HCP Terraform en su cuenta de AWS, pero no evalúa la clave de condición de IAM `app.terraform.io:sub`, recibirá un error. Además, AWS STS denegará las solicitudes de autorización si su política de confianza de roles no evalúa esta clave de condición.

1. La información solicitada varía según el proveedor OIDC que elija.
   + Ingrese el identificador de su aplicación. La etiqueta del identificador cambia en función del proveedor que elija:
     + Si está creando un rol para Inicio de sesión con Amazon, ingrese el ID de la aplicación en el cuadro **ID de aplicación**.
     + Si está creando un rol para Facebook, ingrese el ID de la aplicación en el cuadro **ID de aplicación**.
     + Si está creando un rol para Google, ingrese el nombre de los destinatarios en el cuadro **Público**.
     + Si está creando un rol para Amazon Cognito, ingrese el ID del grupo de identidades que ha creado para sus aplicaciones de Amazon Cognito en el campo **ID de grupo de identidades**.
   + Si quiere crear un rol para GitHub Actions, introduzca los siguientes detalles:
     + En **Público**, elija `sts.amazonaws.com`.
     + Para **Organización de GitHub**, introduzca el nombre de la organización de GitHub. El nombre de la organización de GitHub es obligatorio y debe ser alfanumérico, incluyendo guiones (-). No se pueden usar caracteres comodín (\$1 y ?) en el nombre de la organización de GitHub.
     + (Opcional) Para el **repositorio GitHub**, introduzca el nombre del repositorio GitHub. Si no especifica un valor, se utilizará por defecto un comodín (`*`).
     + (Opcional) Para la **ramificación GitHub**, introduzca el nombre de la ramificación GitHub. Si no especifica un valor, se utilizará por defecto un comodín (`*`).
   + Si quiere crear un rol para HashiCorp Cloud Platform (HCP) Terraform, introduzca los siguientes detalles:
     + En **Público**, elija `aws.workload.identity`.
     + En **Organización**, introduzca el nombre de la organización. Puede especificar un carácter comodín (`*`) para todas las organizaciones.
     + En **Proyecto**, introduzca el nombre del proyecto. Puede especificar un carácter comodín (`*`) para todos los proyectos.
     + En **Espacio de trabajo**, introduzca un nombre del espacio de trabajo. Puede especificar un carácter comodín (`*`) para todos los espacios de trabajo.
     + En **Fase de ejecución**, introduzca el nombre de la fase de ejecución. Puede especificar un carácter comodín (`*`) para todas las fases de ejecución.

1. (Opcional) Para **Condición (opcional)**, elija **Añadir condición** para crear condiciones adicionales que deben cumplirse antes de que los usuarios de su aplicación puedan utilizar los permisos que el rol les concede. Por ejemplo, puede agregar una condición que conceda acceso a recursos de AWS únicamente a un ID de usuario de IAM concreto. También puede añadir condiciones a la política de confianza después de crear el rol. Para obtener más información, consulte [Actualizar una política de confianza de rol](id_roles_update-role-trust-policy.md).

1. Revise la información de OIDC y, a continuación, seleccione **Siguiente**.

1. IAM incluye una lista de las políticas administradas por AWS y de las políticas administradas por el cliente en su cuenta. Seleccione la política que desea utilizar como política de permisos o elija **Crear Política** para abrir una pestaña nueva del navegador y crear una política nueva desde cero. Para obtener más información, consulte [Crear políticas de IAM](access_policies_create-console.md#access_policies_create-start). Después de crear la política, cierre esa pestaña y vuelva a la pestaña original. Seleccione la casilla de verificación situada junto a las políticas de permisos que desea conceder a los usuarios de OIDC. Si lo prefiere, puede optar por no seleccionar ninguna política en este momento y asociar las políticas al rol más adelante. De forma predeterminada, un rol no tiene permisos.

1. (Opcional) Configure un [límite de permisos](access_policies_boundaries.md). Esta es una característica avanzada.

   Abra la sección **Limites de permisos** y elija **Utilizar un límite de permisos para controlar los permisos que puede tener el rol como máximo).** Seleccione la política que desea utilizar para el límite de permisos.

1. Elija **Siguiente**.

1. En **Nombre de rol**, ingrese un nombre de rol. Los nombres de rol deben ser únicos en su Cuenta de AWS. No dependen de los casos. Por ejemplo, no puede crear funciones denominadas tanto **PRODROLE** como **prodrole**. Dado que es posible que otros recursos de AWS hagan referencia al rol, no se puede editar el nombre del rol después de crearlo.

1. (Opcional) En **Descripción**, ingrese una descripción para el nuevo rol.

1. Para editar los casos de uso y los permisos del rol, elija **Editar** en las secciones **(Paso 1: seleccionar entidades de confianza)** o **(Paso 2: agregar permisos).** 

1. (Opcional) Para agregar metadatos al rol, asocie etiquetas como pares clave-valor. Para obtener más información acerca del uso de etiquetas en IAM, consulte [Etiquetas para recursos de AWS Identity and Access Management](id_tags.md).

1. Revise el rol y, a continuación, seleccione **Crear rol**.

## Configuración de un rol para el proveedor de identidades de OIDC de GitHub
<a name="idp_oidc_Create_GitHub"></a>

Si usa GitHub como un proveedor de identidades (IdP) de OIDC, la práctica recomendada es limitar las entidades que pueden asumir el rol asociado con el IdP de IAM. Cuando incluye una declaración de condición en la política de confianza, puede limitar el rol a una organización, un repositorio o una rama de GitHub específica. Puede usar la clave de condición `token.actions.githubusercontent.com:sub` con operadores de condición de cadena para limitar el acceso. Recomendamos limitar la condición a un conjunto específico de repositorios o ramas dentro de la organización GitHub. Para obtener información acerca de cómo configurar AWS para confiar en el OIDC de GitHub como una identidad federada, consulte [GitHub Docs: configuración de OpenID Connect en Amazon Web Services](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services). 

Si utiliza los entornos de GitHub en los flujos de trabajo de acción o en las políticas de OIDC, recomendamos agregar reglas de protección al entorno para una mayor seguridad. Utilice las ramas y las etiquetas de implementación para restringir qué ramas y etiquetas se pueden implementar en el entorno. Para más información sobre la configuración de entornos con reglas de protección, consulte [Ramas y etiquetas de implementación](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-branches-and-tags) en el artículo *Uso de entornos para la implementación* de GitHub.

Cuando el IdP OIDC de GitHub es la entidad principal de confianza para su rol, IAM comprueba la condición de la política de confianza del rol para verificar que la clave de condición `token.actions.githubusercontent.com:sub` está presente y su valor no es únicamente un carácter comodín (\$1 y ?) o nulo. IAM realiza esta comprobación cuando se crea o actualiza la política de confianza. Si la clave de condición `token.actions.githubusercontent.com:sub` no está presente o el valor de la clave no cumple los criterios de valor mencionados, la solicitud fallará y devolverá un error.

**importante**  
Si no limita la clave de condición `token.actions.githubusercontent.com:sub` a una organización o repositorio específicos, GitHub Actions de organizaciones o repositorios fuera de su control pueden asumir roles asociados con el IdP de IAM de GitHub en su cuenta de AWS.

En el siguiente ejemplo de política de confianza se limita el acceso a la organización, el repositorio y la rama de GitHub definidos. El valor de la clave de condición `token.actions.githubusercontent.com:sub` del siguiente ejemplo es el formato de valor del asunto predeterminado documentado por GitHub.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::012345678910:oidc-provider/token.actions.githubusercontent.com"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com",
          "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/GitHubRepo:ref:refs/heads/GitHubBranch"
        }
      }
    }
  ]
}
```

------

La siguiente condición de ejemplo limita el acceso a la organización y el repositorio de GitHub definidos, pero otorga acceso a cualquier rama del repositorio.

```
"Condition": {
  "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
  },
  "StringLike": {    
    "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/GitHubRepo:*"
  }
}
```

La siguiente condición de ejemplo limita el acceso a cualquier rama o repositorio de la organización de GitHub definida. Recomendamos limitar la clave de condición `token.actions.githubusercontent.com:sub` a un valor específico que limite el acceso a GitHub Actions desde dentro de la organización de GitHub.

```
"Condition": {
  "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
  },
  "StringLike": {    
    "token.actions.githubusercontent.com:sub": "repo:GitHubOrg/*"
  }
}
```

Para obtener más información sobre las claves de federación de OIDC disponibles para verificaciones de condición en las políticas, consulte [Claves disponibles para las federaciones de identidades AWS de OIDC](reference_policies_iam-condition-keys.md#condition-keys-wif).

# Creación de un rol para una federación SAML 2.0 (consola)
<a name="id_roles_create_for-idp_saml"></a>

 Puede utilizar la federación SAML 2.0 en lugar de crear usuarios de IAM en una Cuenta de AWS. Con un proveedor de identidad (IdP), puede administrar las identidades de usuario fuera de AWS y conceder permisos a estas identidades de usuarios externos para que tengan acceso a los recursos de AWS de su cuenta. Para obtener más información acerca de la identidad federada y los proveedores de identidad, consulte [Proveedores de identidades y federación en AWS](id_roles_providers.md).

**nota**  
Para mejorar la resiliencia de la federación, le recomendamos que configure su IdP y su federación de AWS para que admitan varios puntos de conexión de inicio de sesión de SAML. Para obtener más información, consulte el artículo del blog sobre seguridad de AWS, [How to use regional SAML endpoints for failover](https://aws.amazon.com/blogs//security/how-to-use-regional-saml-endpoints-for-failover).

## Requisitos previos para crear un rol para SAML
<a name="idp_saml_Prerequisites"></a>

Para poder crear un rol de federación de SAML 2.0, antes debe completar los siguientes pasos de requisitos previos.<a name="saml-prereqs"></a>

**Preparativos para crear un rol para la federación SAML 2.0**

1. <a name="idpsamlstep1"></a>Para poder crear un rol para una federación basada en SAML, debe crear un proveedor de SAML en IAM. Para obtener más información, consulte [Crear un proveedor de identidades de SAML en IAM](id_roles_providers_create_saml.md).

1. Prepare las políticas del rol que los usuarios autenticados por SAML 2.0 asumirán. Al igual que ocurre con cualquier otro rol, un rol para la federación SAML incluye dos políticas. Una es la política de confianza de rol que especifica quién puede asumir el rol. La otra es la política de permisos de IAM que define las acciones de AWS y los recursos a los que la entidad principal federada mediante SAML puede acceder o tiene denegado el acceso.

   Al crear la política de confianza para el rol, debe utilizar tres valores que garantizan que solo la aplicación pueda asumir el rol:
   + En el elemento `Action`, utilice la acción `sts:AssumeRoleWithSAML`.
   + En el elemento `Principal`, utilice la cadena `{"Federated":ARNofIdentityProvider}`. Sustituya `ARNofIdentityProvider` por el ARN del [proveedor de identidad SAML](id_roles_providers_saml.md) que ha creado en [Step 1](#idpsamlstep1).
   + En el elemento `Condition`, utilice una condición `StringEquals` para probar que el atributo `saml:aud` de la respuesta de SAML coincida con la URL que muestra el navegador al iniciar sesión en la consola. Esta URL de punto de conexión de inicio de sesión es el atributo del destinatario de SAML del proveedor de identidades. Puede incluir URL de inicio de sesión en determinadas regiones. AWS recomienda usar los puntos de conexión regionales en lugar del punto de conexión global para mejorar la resiliencia de la federación. Para obtener una lista de los posibles valores de *region-code*, consulte la columna **Region** (Región) en [Puntos de conexión de inicio de sesión de AWS](https://docs.aws.amazon.com/general/latest/gr/signin-service.html).

     Si se requiere el cifrado de SAML, la URL de inicio de sesión debe incluir el identificador único que AWS asigna al proveedor de SAML. Para ver el identificador único, seleccione el proveedor de identidades en la consola de IAM para que aparezca la página de detalles.

     `https://region-code.signin.aws.amazon.com/saml/acs/IdP-ID`

   La política de confianza del ejemplo siguiente está diseñada para un usuario federado de SAML:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Action": "sts:AssumeRoleWithSAML",
           "Principal": {
               "Federated": "arn:aws:iam::111122223333:saml-provider/PROVIDER-NAME"
           },
           "Condition": {
               "StringEquals": {
                   "SAML:aud": "https://region-code.signin.aws.amazon.com/saml"
               }
           }
       }
   }
   ```

------

   Sustituya el ARN de la entidad principal por el ARN real del proveedor SAML que ha creado en IAM. Tendrá su ID de cuenta y su nombre de proveedor. 

## Creación de un rol para SAML
<a name="idp_saml_Create"></a>

Después de completar los pasos de los requisitos previos, puede a crear el rol para la federación basada en SAML. 

**Para crear un rol para la federación basada en SAML**

1. Inicie sesión en Consola de administración de AWS y abra la consola IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación de la consola de IAM, elija **Roles** y, a continuación, elija **Crear rol**.

1. Elija el tipo de rol **SAML 2.0 federation**.

1. En **Select a SAML provider** (Seleccionar un proveedor de SAML), elija el proveedor para el rol. 

1. Elija el método de nivel de acceso SAML 2.0. 
   + Elija **Allow programmatic access only (Permitir solo acceso mediante programación)** para crear un rol que se pueda asumir mediante programación desde la API o la AWS CLI de AWS.
   + Elija **Permitir el acceso Consola de administración de AWS mediante la consola y mediante programación** para crear un rol que pueda ser asumido mediante programación y desde la Consola de administración de AWS.

   Los roles creados con ambas opciones son similares, pero el rol que puede ser asumido desde la consola incluye una política de confianza con una condición particular. Dicha condición garantiza explícitamente que el público de SAML (atributo `SAML:aud`) esté establecido en el punto de conexión de inicio de sesión de AWS para el proveedor de SAML.

1. El procedimiento para definir los atributos varía según el tipo de acceso.
   + Si está creando un rol para el acceso mediante programación, elija un atributo en la lista **Attribute (Atributo)**. A continuación, en el cuadro **Value** (Valor), ingrese un valor para incluirlo en el rol. Esto restringe el acceso del rol a los usuarios del proveedor de identidad cuya respuesta de autenticación SAML (aserción) incluya los atributos que especifique. Debe especificar al menos un atributo para garantiza que el rol esté limitado a un subconjunto de usuarios de su organización. 
   + Si está creando un rol para el acceso mediante programación y a la Consola de administración de AWS, la sección **Puntos de conexión de inicio de sesión** define la URL que muestra el navegador al iniciar sesión en la consola. Este punto de conexión es el atributo de destinatario de SAML del proveedor de identidades, que se asigna a la clave de contexto [`saml:aud`](reference_policies_iam-condition-keys.md#condition-keys-saml). Para obtener más información, consulte [Configure aserciones SAML para la respuesta de autenticación](id_roles_providers_create_saml_assertions.md).

     1. Elija **Puntos de conexión regionales** o **Puntos de conexión no regionales**. Recomendamos utilizar varios puntos de conexión de inicio de sesión de SAML regionales para mejorar la resiliencia de la federación.

     1. En **Regiones**, elija las regiones que admita el proveedor de SAML para el inicio de sesión de AWS.

     1.  En **URL de inicio de sesión para incluir identificadores únicos**, seleccione si los puntos de conexión de inicio de sesión incluyen identificadores únicos que AWS asigna al proveedor de identidades de SAML. Esta opción es obligatoria para las aserciones de SAML cifradas. Para obtener más información, consulte [Federación SAML 2.0](id_roles_providers_saml.md).

1. Para agregar más condiciones relacionadas con el atributo a la política de confianza, elija **Condition (optional)** (Condición [opcional]), seleccione la condición adicional y especifique un valor. 
**nota**  
La lista incluye los atributos SAML utilizados con más frecuencia. IAM admite atributos adicionales que puede utilizar para crear condiciones. Para ver una lista de los atributos admitidos, consulte [Claves disponibles para federaciones SAML](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-saml). Si necesita una condición para un atributo SAML admitido que no se muestra en la lista, puede añadir manualmente dicha condición. Para ello, edite la política de confianza después de crear el rol.

1.  Revise la información de confianza de SAML 2.0 y, a continuación, elija **Next** (Siguiente). 

1. IAM incluye una lista de las políticas administradas por AWS y de las políticas administradas por el cliente en su cuenta. Seleccione la política que desea utilizar como política de permisos o elija **Crear Política** para abrir una pestaña nueva del navegador y crear una política nueva desde cero. Para obtener más información, consulte [Crear políticas de IAM](access_policies_create-console.md#access_policies_create-start). Después de crear la política, cierre esa pestaña y vuelva a la pestaña original. Seleccione la casilla situada junto a las políticas de permisos que desea otorgar a los usuarios federados de SAML. Si lo prefiere, puede optar por no seleccionar ninguna política en este momento y asociar las políticas al rol más adelante. De forma predeterminada, un rol no tiene permisos.

1. (Opcional) Configure un [límite de permisos](access_policies_boundaries.md). Esta es una característica avanzada.

   Abra la sección **Limites de permisos** y elija **Utilizar un límite de permisos para controlar los permisos que puede tener el rol como máximo).** Seleccione la política que desea utilizar para el límite de permisos.

1. Elija **Siguiente**.

1. Elija **Siguiente: Revisar**.

1. En **Nombre de rol**, ingrese un nombre de rol. Los nombres de rol deben ser únicos en su Cuenta de AWS. No distinguen entre mayúsculas y minúsculas. Por ejemplo, no puede crear funciones denominado tanto **PRODROLE** como **prodrole**. Dado que es posible que otros recursos de AWS hagan referencia al rol, no se puede editar el nombre del rol después de crearlo. 

1. (Opcional) En **Description** (Descripción), ingrese una descripción para el nuevo rol.

1. Elija **Edit** (Editar) en las secciones **Step 1: Select trusted entities** (Paso 1: seleccionar entidades de confianza) o **Step 2: Add permissions** (Paso 2: agregar permisos) para editar los casos de uso y los permisos del rol. 

1. De manera opcional, agregue metadatos al rol asociando etiquetas como pares de clave-valor. Para obtener más información acerca del uso de etiquetas en IAM, consulte [Etiquetas para recursos de AWS Identity and Access Management](id_tags.md).

1. Revise el rol y, a continuación, seleccione **Crear rol**.

Después de crear el rol, complete la relación de confianza de SAML configurando su software de proveedor de identidad con información sobre AWS. Esta información incluye los roles que desea que utilicen los usuarios federados de SAML. Esto se denomina configuración de la relación de confianza entre su proveedor de identidad y AWS. Para obtener más información, consulte [Configuración su SAML 2.0 IdP con una relación de confianza para usuario autenticado y agregando reclamos](id_roles_providers_create_saml_relying-party.md). 

# Crear un rol mediante políticas de confianza personalizadas
<a name="id_roles_create_for-custom"></a>

Puede crear una política de confianza personalizada para delegar el acceso y permitir que otros realicen acciones en su Cuenta de AWS. Para obtener más información, consulte [Crear políticas de IAM](access_policies_create-console.md#access_policies_create-start).

Para obtener información sobre cómo utilizar los roles para delegar permisos, consulte [Términos y conceptos de roles](id_roles.md#id_roles_terms-and-concepts).

## Creación de un rol de IAM mediante políticas de confianza personalizadas (consola)
<a name="roles-creatingrole-custom-trust-policy-console"></a>

Puede utilizar la Consola de administración de AWS para crear un rol que un usuario de IAM pueda asumir. Por ejemplo, suponga que su organización tiene varias Cuentas de AWS para aislar un entorno de desarrollo de uno de producción. Para información general sobre cómo crear un rol que permita a usuarios de la cuenta de desarrollo acceder a los recursos de la cuenta de producción, consulte [Situación de ejemplo en la que se usan cuentas de desarrollo y producción separadas](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example).

**Para crear un rol mediante políticas de confianza personalizadas (consola)**

1. Inicie sesión en Consola de administración de AWS y abra la consola IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación de la consola, elija **Roles** y, a continuación, seleccione **Crear rol**.

1. Elija el tipo de rol **Custom trust policy** (Política de confianza personalizada).

1. En la sección **Custom trust policy** (Política de confianza personalizada), ingrese o pegue la política de confianza personalizada para el rol. Para obtener más información, consulte [Crear políticas de IAM](access_policies_create-console.md#access_policies_create-start).

1. Resuelva las advertencias de seguridad, errores o advertencias generales generadas durante la [validación de política](access_policies_policy-validator.md) y luego elija **Next**.

1. (Opcional) Configure un [límite de permisos](access_policies_boundaries.md). Se trata de una característica avanzada que está disponible para los roles de servicio, pero no para los roles vinculados a servicios.

   Abra la sección **Permissions boundary** (Límite de permisos) y elija **Use a permissions boundary to control the maximum role permissions** (Utilizar un límite de permisos para controlar los permisos que puede tener el rol como máximo). IAM incluye una lista de las políticas administradas por AWS y de las políticas administradas por el cliente en su cuenta. Seleccione la política que desea utilizar para el límite de permisos.

1. Elija **Siguiente**.

1. En **Role Name (Nombre del rol)**, el servicio define el grado de personalización del nombre del rol. Si el servicio define el nombre del rol, esta opción no es editable. En otros casos, el servicio puede definir un prefijo para el rol y permitirle escribir un sufijo opcional. Algunos servicios le permiten especificar el nombre completo de su rol.

   Si es posible, ingrese un nombre de rol o un sufijo de nombre de rol. Los nombres de rol deben ser únicos en su Cuenta de AWS. No distinguen entre mayúsculas y minúsculas. Por ejemplo, no puede crear funciones denominado tanto **PRODROLE** como **prodrole**. Dado que es posible que otros recursos de AWS hagan referencia al rol, no se puede editar el nombre del rol después de crearlo.

1. (Opcional) En **Description** (Descripción), ingrese una descripción para el nuevo rol.

1. (Opcional) Seleccione **Editar** en las secciones **Paso 1: seleccionar entidades de confianza** o **Paso 2: agregar permisos** para modificar la política personalizada y los permisos del rol. 

1. De manera opcional, agregue metadatos al rol asociando etiquetas como pares de clave-valor. Para obtener más información acerca del uso de etiquetas en IAM, consulte [Etiquetas para recursos de AWS Identity and Access Management](id_tags.md).

1. Revise el rol y, a continuación, seleccione **Crear rol**.

# Ejemplos de políticas para delegar el acceso
<a name="id_roles_create_policy-examples"></a>

En los siguientes ejemplos se muestra cómo puede permitir o conceder acceso a una Cuenta de AWS a los recursos de otra Cuenta de AWS. Para obtener información sobre cómo crear una política de IAM mediante estos documentos de políticas JSON de ejemplo, consulte [Creación de políticas mediante el editor JSON](access_policies_create-console.md#access_policies_create-json-editor).

**Topics**
+ [

## Uso de roles para delegar el acceso a otros recursos de la Cuenta de AWS
](#example-delegate-xaccount-rolesapi)
+ [

## Uso de una política para delegar el acceso a los servicios
](#id_roles_create_policy-examples-access-to-services)
+ [

## Uso de una política basada en recursos para delegar el acceso a un bucket de Amazon S3 de otra cuenta
](#example-delegate-xaccount-S3)
+ [

## Uso de una política basada en recursos para delegar el acceso a una cola de Amazon SQS de otra cuenta
](#example-delegate-xaccount-SQS)
+ [

## No se puede delegar el acceso cuando la cuenta tiene el acceso denegado
](#example-delegate-xaccount-SQS-denied)

## Uso de roles para delegar el acceso a otros recursos de la Cuenta de AWS
<a name="example-delegate-xaccount-rolesapi"></a>

 Para ver un tutorial que muestra cómo utilizar los roles de IAM para conceder a los usuarios de una cuenta acceso a los recursos de AWS que se encuentran en otra cuenta, consulte [Tutorial de IAM: delegación del acceso entre cuentas de AWS mediante roles de IAM](tutorial_cross-account-with-roles.md). 

**importante**  
Puede incluir el ARN de un rol o usuario específico en el elemento `Principal` de una política de confianza de rol. Al guardar la política, AWS transforma el ARN a un ID exclusivo de entidad principal. Esto ayuda a mitigar el riesgo de que alguien aumente sus privilegios eliminando o volviendo a crear el rol o usuario. Normalmente este ID no se muestra en la consola, ya que también existe una transformación inversa al ARN cuando se muestra la política de confianza. Sin embargo, si elimina el rol o el usuario, la relación se desvincula. La política ya no se aplica, incluso si vuelva a crear el usuario o rol, ya que no coincide con el ID principal almacenado en la política de confianza. Cuando esto sucede, el ID principal se muestra en la consola, ya que AWS no puede volver a asignarlo a un ARN. El resultado es que si elimina y vuelve a crear un usuario o rol al que se hace referencia en un elemento `Principal` de la política de confianza, debe editar el rol para sustituir el ARN. Se transforma en el nuevo ID de entidad principal al guardar la política.

## Uso de una política para delegar el acceso a los servicios
<a name="id_roles_create_policy-examples-access-to-services"></a>

En el siguiente ejemplo se muestra una política que puede asociarse a un rol. La política permite que dos servicios, Amazon EMR y AWS Data Pipeline asuman el rol. Los servicios pueden realizar las tareas concedidas por la política de permisos asignada al rol (no se muestra). Para especificar varios elementos principales del servicio, no debe especificar dos elementos `Service`; solo puede tener uno. En cambio, utilice una gama de varios elementos principales del servicio como el valor de un único elemento `Service`.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "elasticmapreduce.amazonaws.com",
          "datapipeline.amazonaws.com"
        ]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

------

## Uso de una política basada en recursos para delegar el acceso a un bucket de Amazon S3 de otra cuenta
<a name="example-delegate-xaccount-S3"></a>

En este ejemplo, la cuenta A utiliza una política basada en recursos (una [política de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucketPolicies.html) de Amazon S3) para conceder a la cuenta B acceso completo al bucket de S3 de la cuenta A. A continuación, la cuenta B crea una política de usuario de IAM para delegar el acceso del bucket de la cuenta A a uno de los usuarios de la cuenta B. 

La política de bucket de S3 de la cuenta A podría ser como la siguiente política. En este ejemplo, el bucket de S3 de la cuenta A se llama *amzn-s3-demo-bucket*, mientras que el número de cuenta de la cuenta B es 111122223333. No se especifica los usuarios individuales ni grupos de la cuenta B, solo la cuenta.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Sid": "AccountBAccess1",
    "Effect": "Allow",
    "Principal": {"AWS": "111122223333"},
    "Action": "s3:*",
    "Resource": [
      "arn:aws:s3:::amzn-s3-demo-bucket",
      "arn:aws:s3:::amzn-s3-demo-bucket/*"
    ]
  }
}
```

------

De forma alternativa, la cuenta A puede utilizar las [Listas de control de acceso (ACL)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3_ACLs_UsingACLs.html) de Amazon S3 para conceder a la cuenta B acceso a un bucket de S3 o a un único objeto de un bucket. En tal caso, lo único que cambia es cómo la cuenta A concede acceso a la cuenta B. La cuenta B todavía utiliza una política para delegar el acceso a un grupo de IAM de la cuenta B, tal y como se describe en la próxima sección de este ejemplo. Para obtener más información sobre el control del acceso a los buckets y objetos de S3, vaya a [Control de acceso](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingAuthAccess.html) en la *Guía del usuario de Amazon Simple Storage Service*. 

El administrador de la cuenta B puede crear la siguiente muestra de política. La política permite el acceso de lectura a un grupo o usuario de la cuenta B. La política anterior concede acceso a la cuenta B. Sin embargo, los grupos y usuarios individuales de la cuenta B no pueden obtener acceso al recurso hasta que una política de grupo o usuario conceda de forma explícita los permisos al recurso. Los permisos de esta política solo pueden ser un subconjunto de los de la anterior política entre cuentas. La cuenta B no puede conceder más permisos a sus grupos y usuarios que los que la cuenta A concedió a la cuenta B en la primera política. En esta política, el elemento `Action` se define de forma explícita para permitir únicamente acciones `List` y el elemento `Resource` de esta política coincide con `Resource` para la política de bucket implementada por la cuenta A.

Para aplicar esta política, la cuenta B utiliza IAM para asociarla al usuario adecuado (o grupo) de la cuenta B. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:List*",
    "Resource": [
      "arn:aws:s3:::amzn-s3-demo-bucket",
      "arn:aws:s3:::amzn-s3-demo-bucket/*"
    ]
  }
}
```

------

## Uso de una política basada en recursos para delegar el acceso a una cola de Amazon SQS de otra cuenta
<a name="example-delegate-xaccount-SQS"></a>

En el siguiente ejemplo, la cuenta A tiene una cola de Amazon SQS que utiliza una política basada en recursos asociados a la cola para conceder acceso a la cola a la cuenta B. A continuación, la cuenta B utiliza una política de grupo de IAM para delegar el acceso a un grupo de la cuenta B. 

En el siguiente ejemplo una política de cola concede permiso a la cuenta B para realizar las acciones `SendMessage` y `ReceiveMessage` en la cola de la cuenta A denominada *queue1*, pero solo entre las 12:00 h y las 15:00 h del 30 de noviembre de 2014. El número de la cuenta B es 1111-2222-3333. La cuenta A utiliza Amazon SQS para implementar esta política. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Principal": {"AWS": "111122223333"},
    "Action": [
      "sqs:SendMessage",
      "sqs:ReceiveMessage"
    ],
    "Resource": ["arn:aws:sqs:*:123456789012:queue1"],
    "Condition": {
      "DateGreaterThan": {"aws:CurrentTime": "2014-11-30T12:00Z"},
      "DateLessThan": {"aws:CurrentTime": "2014-11-30T15:00Z"}
    }
  }
}
```

------

La política de la cuenta B para delegar el acceso a un grupo de la cuenta B podría ser como el siguiente ejemplo. La cuenta B utiliza IAM para asociar esta política a un grupo (o usuario). 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "sqs:*",
    "Resource": "arn:aws:sqs:*:123456789012:queue1"
  }
}
```

------

En el ejemplo anterior de la política de usuario de IAM, la cuenta B utiliza un carácter comodín para conceder acceso a su usuario a todas las acciones de Amazon SQS en la cola de la cuenta A. Sin embargo, la cuenta B puede delegar el acceso únicamente en la medida en que se haya concedido acceso a dicha cuenta. El grupo de la cuenta B que tenga la segunda política solo puede obtener acceso a la cola entre las 12:00 y las 3:00 el 30 de noviembre de 2014. El usuario solo puede realizar las acciones `SendMessage` y `ReceiveMessage`, según se define en la política de cola de Amazon SQS de la cuenta A. 

## No se puede delegar el acceso cuando la cuenta tiene el acceso denegado
<a name="example-delegate-xaccount-SQS-denied"></a>

Una Cuenta de AWS no puede delegar el acceso a los recursos de otra cuenta si la otra cuenta ha denegado de forma explícita el acceso a la cuenta principal del usuario. La denegación se propaga a los usuarios de dicha cuenta independientemente de que tengan políticas que les conceda acceso.

Por ejemplo, la cuenta A escribe una política de bucket en el bucket de S3 de la cuenta A que deniega de forma explícita el acceso de la cuenta B al bucket de la cuenta A. Pero la cuenta B escribe una política de usuario de IAM que concede a un usuario de la cuenta B acceso a un bucket de la cuenta A. La denegación explícita aplicada al bucket de S3 de la cuenta A se propaga a los usuarios de la cuenta B. Anula la política de usuario de IAM que concede acceso al usuario de la cuenta B (para obtener más información sobre se evalúan cómo los permisos, consulte [Lógica de evaluación de políticas](reference_policies_evaluation-logic.md).) 

La política de bucket de la cuenta A podría ser como la siguiente política. En este ejemplo, el bucket de S3 de la cuenta A se llama *amzn-s3-demo-bucket*, mientras que el número de cuenta de la cuenta B es 1111-2222-3333. La cuenta A utiliza Amazon S3 para implementar esta política. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Sid": "AccountBDeny",
    "Effect": "Deny",
    "Principal": {"AWS": "111122223333"},
    "Action": "s3:*",
    "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
  }
}
```

------

Esta denegación explícita anula cualquier políticas de la cuenta B que proporcione permiso para obtener acceso al bucket de S3 en la cuenta A. 

# Administración de roles de IAM
<a name="id_roles_manage"></a>

Para que un usuario, una aplicación o un servicio pueda utilizar un rol creado por usted, debe conceder permisos para cambiar al rol. Puede utilizar cualquier política asociada a grupos o usuarios para otorgar los permisos necesarios. En esta sección se describe cómo se puede conceder a los usuarios el permiso para utilizar un rol. También explica cómo el usuario puede cambiar a un rol desde el Consola de administración de AWS, Tools for Windows PowerShell, AWS Command Line Interface (AWS CLI) y el API de [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html).

**importante**  
Cuando crea un rol mediante programación en lugar de hacerlo en la consola de IAM, tiene la opción de agregar un `Path` de 512 caracteres como máximo además del `RoleName`, que puede tener un máximo de 64 caracteres. Sin embargo, si desea utilizar un rol con la característica **Cambiar rol** en la consola de Consola de administración de AWS, la combinación de `Path` y `RoleName` no puede superar los 64 caracteres.

**Topics**
+ [

## Ver Acceso de roles
](#roles-modify_prerequisites)
+ [

## Generar una política basada en información de acceso
](#roles-modify_gen-policy)
+ [

# Conceder a un usuario permisos para cambiar de rol
](id_roles_use_permissions-to-switch.md)
+ [

# Conceder permisos a un usuario para transferir un rol a un servicio de AWS
](id_roles_use_passrole.md)
+ [

# Revocación de las credenciales de seguridad temporales de un rol de IAM
](id_roles_use_revoke-sessions.md)
+ [

# Actualizar un rol vinculado a servicios
](id_roles_update-service-linked-role.md)
+ [

# Actualizar una política de confianza de rol
](id_roles_update-role-trust-policy.md)
+ [

# Actualización de los permisos de un rol
](id_roles_update-role-permissions.md)
+ [

# Actualización de la configuración de un rol
](id_roles_update-role-settings.md)
+ [

# Eliminar roles o perfiles de instancia
](id_roles_manage_delete.md)

## Ver Acceso de roles
<a name="roles-modify_prerequisites"></a>

Antes de cambiar los permisos para un rol, debe revisar su actividad de nivel de servicio reciente. Esto es importante porque no desea eliminar el acceso de un principal (persona o aplicación) que está utilizándolo. Para obtener más información acerca de cómo ver la información de acceso reciente, consulte [Ajuste de permisos en AWS con información sobre los últimos accesos](access_policies_last-accessed.md).

## Generar una política basada en información de acceso
<a name="roles-modify_gen-policy"></a>

A veces puede conceder permisos a una entidad de IAM (usuario o rol) de más allá de lo que requieren. Para ayudarle a refinar los permisos que concede, puede generar una política de IAM que esté basada en la actividad de acceso de una entidad. El analizador de acceso de IAM revisa los registros de AWS CloudTrail y genera una plantilla de política que contiene los permisos que ha utilizado la entidad en el intervalo de fechas especificado. Puede utilizar la plantilla para crear una política administrada con permisos detallados y, a continuación, adjuntarla a la entidad de IAM. De esta forma, solo concede los permisos que el usuario o rol necesita para interactuar con los recursos de AWS para su caso de uso específico. Para obtener más información, consulte [Generación de políticas del Analizador de acceso de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-generation.html).

# Conceder a un usuario permisos para cambiar de rol
<a name="id_roles_use_permissions-to-switch"></a>

Cuando un administrador [crea un rol para el acceso entre cuentas](id_roles_create_for-user.md), establece la confianza entre la cuenta propietaria del rol, los recursos (cuenta de confianza) y la cuenta que contiene a los usuarios (cuenta de confianza). Para ello, el administrador de la cuenta de confianza especifica el número de la cuenta de confianza como `Principal` en la política de confianza del rol. Esto permite que *potencialmente* cualquier usuario de la cuenta de confianza asuma el rol. Para finalizar la configuración, el administrador de la cuenta de confianza debe conceder permiso a usuarios o grupos específicos de dicha cuenta para cambiar al rol.

**Para conceder permiso para cambiar a un rol**

1. Como administrador de la cuenta de confianza, cree una política nueva para el usuario o edite una política existente para agregar los elementos necesarios. Para obtener más información, consulte [Creación o edición de la política](#roles-usingrole-createpolicy).

1. A continuación, elija cómo desea compartir la información del rol: 
   + **Enlace de rol**: envíe a los usuarios un enlace que los lleve a la página **Switch Role** (Cambiar el rol) con todos los detalles ya completados. 
   + **ID de cuenta o alias**: proporcione a cada usuario el nombre de la función junto con el número de ID de cuenta o alias de cuenta. El usuario se dirige a la página **Switch Role (Cambiar rol)** y agrega los detalles manualmente. 

   Para obtener más información, consulte [Proporcionar información al usuario](#roles-usingrole-giveuser).

Tenga en cuenta que solo puede cambiar de rol cuando inicia sesión como usuario de IAM, como rol federado de SAML o como un rol federado de identidad web. No puede cambiar de rol si inicia sesión como usuario Usuario raíz de la cuenta de AWS.

**importante**  
No puede cambiar roles en la Consola de administración de AWS a un rol que requiera un valor [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id). Solo puede cambiar a dicho rol si llama a la API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) que admite el parámetro `ExternalId`.

**Notas**  
En este tema se explican las políticas para un *usuario*, ya que, en última instancia, concedemos permisos a un usuario para llevar a cabo una tarea. Sin embargo, no es recomendable conceder permisos a un usuario en particular. Cuando un usuario asume un rol, se le asignan los permisos asociados a ese rol.
Al cambiar de rol en la Consola de administración de AWS, la consola utiliza siempre sus credenciales originales para autorizar el cambio. Esto se aplica tanto si inicia sesión como usuario de IAM, como rol federado SAML o como un rol federado de identidad web. Por ejemplo, si cambia a RoleA, IAM utiliza las credenciales originales del usuario o del rol federado para determinar si está autorizado para asumir RoleA. Si trata de cambiar a RoleB *mientras utiliza RoleA*, las credenciales **originales** del usuario o del rol federado se utilizan para autorizar su intento. Las credenciales de RoleA no se utilizan para esta acción.

**Topics**
+ [

## Creación o edición de la política
](#roles-usingrole-createpolicy)
+ [

## Proporcionar información al usuario
](#roles-usingrole-giveuser)

## Creación o edición de la política
<a name="roles-usingrole-createpolicy"></a>

Una política que concede a un usuario permiso para asumir un rol debe incluir una instrucción con el efecto `Allow` en lo siguiente: 
+ Acción `sts:AssumeRole`
+ El nombre de recurso de Amazon (ARN) de un rol en un elemento `Resource`

A los usuarios que obtienen la política se les permite cambiar de rol en el recurso enumerado (ya sea a través de la pertenencia a un grupo o directamente conectado).

**nota**  
Si `Resource` está configurado en `*`, el usuario puede asumir cualquier rol en cualquier cuenta que tenga una relación de confianza con la cuenta del usuario. (En otras palabras, la política de confianza del rol especifica la cuenta del usuario como `Principal`). Le recomendamos que siga el [principio de mínimo privilegio](http://en.wikipedia.org/wiki/Principle_of_least_privilege) y especifique el ARN completo únicamente para los roles que necesite el usuario.

En el siguiente ejemplo se muestra una política que permite al usuario asumir roles solo en una cuenta. Además, la política utiliza un asterisco (\$1) para especificar que el usuario puede cambiar a un rol solo si el nombre del rol comienza por las letras `Test`.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Effect": "Allow",
        "Action": "sts:AssumeRole",
        "Resource": "arn:aws:iam::111122223333:role/Test*"
    }
}
```

------

**nota**  
Los permisos que el rol concede al usuario no se agregan a los permisos que se le han concedido anteriormente. Si un usuario cambia a un rol, el usuario temporalmente renuncia a sus permisos originales a cambio de los concedidos por el rol. Si el usuario deja de utilizar el rol, sus permisos originales se restablecerán automáticamente. Por ejemplo, supongamos que los permisos del usuario dejan trabajar con instancias Amazon EC2, pero la política de permisos del rol no concede esos permisos. En ese caso, al utilizar el rol, el usuario no puede trabajar con instancias Amazon EC2 en la consola. Además, las credenciales temporales obtenidas a través de `AssumeRole` no funcionarán con instancias Amazon EC2 mediante programación.

## Proporcionar información al usuario
<a name="roles-usingrole-giveuser"></a>

Después de crear un rol y conceder al usuario permisos para cambiar a dicho rol, debe proporcionar al usuario lo siguiente:
+ El nombre del rol
+ El ID o alias de la cuenta que contiene el rol

Para agilizar el acceso de sus usuarios, puede enviarles un enlace preconfigurado con el ID de la cuenta y el nombre de la función. Puede ver el enlace del rol después de completar el asistente de creación **Crear rol** si selecciona el banner **Ver rol**, o en la página **Resumen del rol** para cualquier rol habilitado para varias cuentas.

También puede utilizar el siguiente formato para crear manualmente el enlace. Sustituya el alias o ID de la cuenta y el nombre del rol por los dos parámetros en el siguiente ejemplo.

`https://signin.aws.amazon.com/switchrole?account=your_account_ID_or_alias&roleName=optional_path/role_name`

Le recomendamos que dirija a los usuarios a [Cambiar de usuario a rol de IAM (consola)](id_roles_use_switch-role-console.md) para guiarles durante el proceso. Para solucionar problemas comunes que se pueden encontrar al asumir un rol, consulte [No puedo asumir un rol](troubleshoot_roles.md#troubleshoot_roles_cant-assume-role).

**Consideraciones**
+ Si crea el rol mediante programación, puede crear el rol con una ruta y un nombre. Si lo hace, debe proporcionar la ruta de acceso completa y el nombre del rol a los usuarios para que puedan ingresarlos en la página **Cambiar rol** de la Consola de administración de AWS. Por ejemplo: `division_abc/subdivision_efg/role_XYZ`.
+ Si crea el rol mediante programación, puede agregar un `Path` de hasta 512 caracteres y un `RoleName`. El nombre del rol puede tener una longitud de hasta 64 caracteres. Sin embargo, si desea utilizar un rol con la característica **Cambiar rol** en Consola de administración de AWS, la combinación de `Path` y `RoleName` no puede superar los 64 caracteres.
+ Por motivos de seguridad, puede [revisar los registros de AWS CloudTrail](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) para saber quién realizó una acción en AWS. Puede utilizar la clave de condición de `sts:SourceIdentity` en la política de confianza de rol para exigir a los usuarios que especifiquen una identidad cuando asuman un rol. Por ejemplo, puede requerir que los usuarios de IAM especifiquen su propio nombre de usuario como su identidad de origen. Esto puede permitirle determinar qué usuario hizo una acción específica en AWS. Para obtener más información, consulte [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity). También puede utilizar [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname) para exigir a los usuarios que especifiquen un nombre de sesión cuando asuman un rol. Esto puede permitirle diferenciar entre sesiones de rol cuando diferentes entidades utilizan un rol.

# Conceder permisos a un usuario para transferir un rol a un servicio de AWS
<a name="id_roles_use_passrole"></a>

Para configurar muchos servicios de AWS, es necesario *transferir* un rol de IAM al servicio. Esto permite al servicio asumir posteriormente el rol y ejecutar acciones en su nombre. Para muchos servicios, solo tiene que transferir el rol al servicio una vez durante la configuración y no cada vez que el servicio asume el rol. Por ejemplo, suponga que tiene una aplicación que se ejecuta en una instancia de Amazon EC2. Dicha aplicación requiere credenciales temporales para la autenticación, así como permisos para realizar acciones en AWS. Cuando configure la aplicación, debe transferir un rol a Amazon EC2 para que lo utilice con la instancia que proporciona dichas credenciales. Puede definir los permisos de las aplicaciones que se ejecutan en la instancia asociando una política de IAM al rol. La aplicación asume el rol cada vez que necesita realizar las acciones que este permite.

Para transferir un rol (y sus permisos) a un servicio de AWS, un usuario debe tener permisos para *transferir el rol* al servicio. Esto ayuda a los administradores a garantizar que solo los usuarios autorizados puedan configurar un servicio con un rol que concede permisos. Para permitir a un usuario transferir un rol a un servicio de AWS, debe conceder el permiso `PassRole` al usuario, rol o grupo de IAM del usuario.

**aviso**  
Solo puede usar el permiso `PassRole` para transferir un rol de IAM a un servicio que comparte la misma cuenta de AWS. Para transferir una función de la cuenta A a un servicio de la cuenta B, primero debe crear un rol de IAM en la cuenta B que pueda asumir la función desde la cuenta A y, a continuación, la función de la cuenta B se puede transferir al servicio. Para obtener más información, consulte [Acceso a recursos entre cuentas en IAM](access_policies-cross-account-resource-access.md).
No intente controlar quién puede pasar un rol etiquetando el rol y, a continuación, utilizando la clave de condición `ResourceTag` en una política con la acción `iam:PassRole`. Este planteamiento no da resultados fiables.

Al configurar el permiso `PassRole`, debe asegurarse de que un usuario no pase un rol en el que el rol tenga más permisos de los que usted desea que tenga el usuario. Por ejemplo, es posible que a Alice no se le permita realizar ninguna acción de Amazon S3. Si Alice pudiera transferir un rol a un servicio que permita acciones de Amazon S3, el servicio podría realizar acciones de Amazon S3 en su nombre al ejecutar el trabajo.

Si especifica un rol vinculado a un servicio, debe disponer también de permiso para transferir ese rol al servicio. Algunos servicios crean automáticamente un rol vinculado a un servicio en su cuenta al realizar una acción en dicho servicio. Por ejemplo, Amazon EC2 Auto Scaling crea el rol vinculado a un servicio `AWSServiceRoleForAutoScaling` automáticamente la primera vez que se crea un grupo de Auto Scaling. Si intenta especificar el rol vinculado a un servicio al crear un grupo de escalado automático y no posee el permiso `iam:PassRole`, recibirá un error. Si no especifica el rol de manera explícita, el permiso `iam:PassRole` no es necesario y la acción predeterminada es usar el rol `AWSServiceRoleForAutoScaling` para todas las operaciones que se realicen en ese grupo. Para saber qué servicios admiten roles vinculados a servicios, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md). Para saber qué servicios crean automáticamente un rol vinculado a un servicio al realizar una acción en ellos, elija el enlace **Sí** y consulte la documentación relacionada con los roles vinculados a dicho servicio.

Un usuario puede pasar un ARN de rol como parámetro en cualquier operación de API que utilice el rol para asignar permisos al servicio. A continuación, el servicio comprueba si ese usuario tiene el permiso `iam:PassRole`. Para que el usuario transfiera únicamente los roles autorizados, puede filtrar el permiso `iam:PassRole` con el elemento `Resources` de la instrucción de política de IAM. 

Puede utilizar el elemento `Condition` en una política JSON para probar el valor de las claves incluidas en el contexto de solicitud de todas las solicitudes de AWS. Para obtener más información acerca del uso de las claves de condición en una política, consulte [Elementos de política JSON de IAM: Condition](reference_policies_elements_condition.md). La clave de condición `iam:PassedToService` se puede utilizar para especificar la entidad principal del servicio al que se puede pasar un rol. Para obtener más información acerca del uso de la clave de condición `iam:PassedToService` en una política, consulte [iam:PassedToService](reference_policies_iam-condition-keys.md#ck_PassedToService).

**Ejemplo 1**  
Supongamos que desea conceder a un usuario la capacidad de transferir cualquier conjunto de roles al servicio de Amazon EC2 cuando se lanza una instancia. Necesita tres elementos:
+ Una *política de permisos* de IAM asociada al rol que determina lo que puede hacer dicho rol. Limite los permisos a únicamente las acciones que deba llevar a cabo el rol y únicamente los recursos que el rol necesite para dichas acciones. Puede utilizar una política de permisos de IAM creada por el cliente o administrada por AWS.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": {
          "Effect": "Allow",
          "Action": [ "A list of the permissions the role is allowed to use" ],
          "Resource": [ "A list of the resources the role is allowed to access" ]
      }
  }
  ```

------
+ Una* política de confianza* para el rol que permita al servicio asumir dicho rol. Por ejemplo, puede adjuntar la siguiente política de confianza al rol con la acción `UpdateAssumeRolePolicy`. Esta política de confianza permite a Amazon EC2 utilizar el rol y los permisos asociados al rol.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": {
          "Sid": "TrustPolicyStatementThatAllowsEC2ServiceToAssumeTheAttachedRole",
          "Effect": "Allow",
          "Principal": { "Service": "ec2.amazonaws.com" },
         "Action": "sts:AssumeRole"
      }
  }
  ```

------
+ Una *política de permisos* de IAM asociada al usuario de IAM que le permite especificar únicamente los roles aprobados. Normalmente agrega `iam:GetRole` a `iam:PassRole`, de modo que el usuario pueda obtener los detalles del rol que se transfiere. En este ejemplo, el usuario puede pasar únicamente los roles que existen en la cuenta especificada con nombres que empiezan por `EC2-roles-for-XYZ-`:

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "iam:GetRole",
                  "iam:PassRole"
              ],
              "Resource": "arn:aws:iam::111122223333:role/EC2-roles-for-XYZ-*"
          }
      ]
  }
  ```

------

Ahora el usuario puede iniciar una instancia de Amazon EC2 con un rol asignado. Las aplicaciones que se ejecutan en la instancia pueden acceder a credenciales temporales para el rol a través de los metadatos del perfil de instancia. Las políticas de permisos asociadas al rol determinan lo que puede hacer la instancia. 

**Ejemplo 2**  
Amazon Relational Database Service (Amazon RDS) admite una característica denominada **Monitoreo mejorado**. Esta característica permite a Amazon RDS monitorear una instancia de base de datos mediante un agente. También permite a Amazon RDS registrar métricas en Amazon CloudWatch Logs. Para habilitar esta característica, debe crear una función de servicio para otorgar a Amazon RDS permisos para monitorear y escribir métricas en los registros. 

**Para crear un rol para el monitoreo mejorado de Amazon RDS**

1. Inicie sesión en Consola de administración de AWS y abra la consola IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Elija **Roles** y después **Crear rol**.

1. Elija el tipo de rol de **Servicio de AWS** y, a continuación, en **Casos de uso para otros Servicios de AWS**, elija el servicio **RDS**. Elija **RDS - Supervisión mejorada** y, a continuación, elija **Siguiente**.

1. Elija la política de permisos **AmazonRDSEnhancedMonitoringRole**.

1. Elija **Siguiente**.

1. En **Nombre del rol**, ingrese un nombre de rol que le sea útil para identificar su propósito. Los nombres de rol deben ser únicos en su Cuenta de AWS. Cuando se utiliza un nombre de rol en una política o como parte de un ARN, el nombre del rol distingue entre mayúsculas y minúsculas. Cuando los clientes ven un nombre de rol en la consola, por ejemplo, durante el proceso de inicio de sesión, el nombre del rol no distingue entre mayúsculas y minúsculas. Dado que varias entidades pueden hacer referencia al rol, no se puede editar el nombre del rol una vez que se crea.

1. (Opcional) En **Description** (Descripción), ingrese una descripción para el nuevo rol.

1. (Opcional) Adjunte etiquetas como pares de clave-valor para agregar metadatos al rol. Para obtener más información acerca del uso de etiquetas en IAM, consulte [Etiquetas para recursos de AWS Identity and Access Management](id_tags.md).

1. Revise el rol y, a continuación, seleccione **Crear rol**.

Automáticamente, el rol recibe una política de confianza que otorga los permisos de servicio `monitoring.rds.amazonaws.com` para asumir el rol. Después, Amazon RDS podrá realizar todas las acciones que permite la política `AmazonRDSEnhancedMonitoringRole`.

El usuario para el que desea habilitar la supervisión mejorada necesita una política que incluya una declaración que permita al usuario enumerar los roles de RDS y una declaración que le permita transferir el rol, como la siguiente. Utilice el número de cuenta y sustituya el nombre del rol por el nombre que ha facilitado en el paso 6.

```
    {
      "Sid": "PolicyStatementToAllowUserToListRoles",
      "Effect": "Allow",
      "Action": ["iam:ListRoles"],
      "Resource": "*"
    },
    {
        "Sid": "PolicyStatementToAllowUserToPassOneSpecificRole",
        "Effect": "Allow",
        "Action": [ "iam:PassRole" ],
        "Resource": "arn:aws:iam::account-id:role/RDS-Monitoring-Role"
    }
```

Puede combinar esta instrucción con instrucciones de otra política o colocarla en su propia política. En lugar de especificar que el usuario pueda transferir cualquier rol que empieza por `RDS-`, puede sustituir el nombre del rol en el ARN del recurso por un comodín, de la siguiente manera.

```
        "Resource": "arn:aws:iam::account-id:role/RDS-*"
```

## Acciones `iam:PassRole` en registros de AWS CloudTrail
<a name="id_roles_use_passrole_logs"></a>

 `PassRole` no es una llamada a la API. `PassRole` es un permiso, lo que significa que no se generan registros de CloudTrail para `PassRole` de IAM. Para revisar qué roles se pasan a qué Servicios de AWS en CloudTrail, debe revisar el registro de CloudTrail que creó o modificó el recurso de AWS que recibe el rol. Por ejemplo, un rol se pasa a una función de AWS Lambda cuando se crea. El registro de la acción `CreateFunction` muestra un registro del rol que se pasó a la función. 

# Revocación de las credenciales de seguridad temporales de un rol de IAM
<a name="id_roles_use_revoke-sessions"></a>

**aviso**  
Si sigue los pasos que se indican en esta página, se denegará el acceso a todas las acciones y recursos de AWS a todos los usuarios con sesiones actuales que se hayan creado adoptando el rol. Esto puede hacer que los usuarios pierdan el trabajo que no hayan guardado.

Cuando habilita a los usuarios para obtener acceso a la Consola de administración de AWS en una sesión de larga duración (como, por ejemplo, 12 horas), sus credenciales temporales no caducan tan rápidamente. Si los usuarios revelan accidentalmente sus credenciales a un tercero no autorizado, ese tercero podrá obtener acceso mientras dure la sesión. Sin embargo, si es preciso, puede revocar inmediatamente todos los permisos de las credenciales del rol emitidas antes de un momento dado. Todas las credenciales temporales de dicho rol que se hayan emitido antes de ese momento dado dejarán de ser válidas. Esto obliga a todos los usuarios a volver a autenticarse y a solicitar credenciales nuevas.

 

**nota**  
No se puede revocar la sesión de un *[rol vinculado a un servicio](id_roles.md#iam-term-service-linked-role)*.

Cuando revoca los permisos de un rol ejecutando el procedimiento indicado en este tema, AWS asocia una política insertada nueva al rol que deniega todos los permisos para todas las acciones. Incluye una condición que aplica las restricciones solo si el usuario asumió el rol *antes* del momento en que usted revocó los permisos. Si el usuario asume el rol *después* de que usted revocara los permisos, la política de denegación no se aplica a ese usuario.

Para obtener más información sobre cómo denegar el acceso, consulte [Deshabilitar permisos para credenciales de seguridad temporales](id_credentials_temp_control-access_disable-perms.md).

**importante**  
Esta política de denegación se aplica a todos los usuarios del rol especificado y no solo a las sesiones de la consola de más larga duración.

## Permisos mínimos para revocar permisos de sesión de un rol.
<a name="revoke-session-permissions"></a>

Para poder revocar efectivamente los permisos de sesión de un rol, debe tener el permiso `PutRolePolicy` para el rol. Esto le permite asociar la política insertada `AWSRevokeOlderSessions` al rol.

## Revocación de permisos de sesión.
<a name="revoke-session"></a>

Puede revocar los permisos de sesión de un rol para denegar todos los permisos a cualquier usuario que haya asumido el rol.

**nota**  
No puede editar los roles en IAM que se hayan creado a partir de conjuntos de permisos del IAM Identity Center. Debe revocar la sesión del conjunto de permisos activo para un usuario en el IAM Identity Center. Para obtener más información, consulte [Revocar sesiones de rol de IAM creadas por conjuntos de permisos](https://docs.aws.amazon.com/singlesignon/latest/userguide/useraccess.html#revoke-user-permissions) en la *Guía del usuario de IAM Identity Center*.

**Para denegar inmediatamente todos los permisos a cualquier usuario de credenciales de rol**

1. Inicie sesión en Consola de administración de AWS y abra la consola IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación, seleccione **Roles** y, a continuación, elija el nombre (no la casilla de verificación) del rol cuyos permisos desee revocar.

1. En la página **Summary (Resumen)** del rol seleccionado, elija la pestaña **Revoke sessions (Revocar sesiones)**.

1. En la pestaña **Revoke sessions (Revocar sesiones)**, seleccione **Revoke active sessions (Revocar sesiones activas)**.

1. AWS le solicitará que confirme la acción. Seleccione la casilla **Confirmo que voy a revocar todas las sesiones activas de este rol** y elija **Revocar sesiones activas** en el cuadro de diálogo.

   IAM asociará inmediatamente una política llamada `AWSRevokeOlderSessions` al rol. Al elegir **Revocar sesiones activas**, la política denegará el acceso a los usuarios que asumieron el rol en el pasado y en aproximadamente 30 segundos en el futuro. Esta elección de hora futura tiene en cuenta el retraso de propagación de la política para tratar una nueva sesión que se adquirió o renovó antes de que la política actualizada entre en vigor en una región determinada. Ningún usuario que haya asumido el rol aproximadamente 30 segundos después de que usted haya elegido Revocar sesiones activas no resultará afectado. Para saber por qué los cambios no siempre son visibles inmediatamente, consulte [Los cambios que realizo no están siempre visibles inmediatamente](troubleshoot.md#troubleshoot_general_eventual-consistency). 

**nota**  
Si más tarde vuelve a elegir **Revocar sesiones**, la fecha y la marca temporal de la política se actualizarán y la política volverá a denegar todos los permisos a todos los usuarios que asumieron el rol antes de la nueva hora especificada.

Los usuarios válidos cuyas sesiones se revocan de esta forma deben obtener credenciales temporales para una nueva sesión para poder seguir trabajando. Las credenciales de caché de la AWS CLI hasta que caducan. Para obligar a la CLI a eliminar y actualizar las credenciales en caché que ya no son válidas, ejecute uno de los comandos siguientes:

**Linux, macOS o Unix**

```
$ rm -r ~/.aws/cli/cache
```

**Windows**

```
C:\> del /s /q %UserProfile%\.aws\cli\cache
```

## Revocación de los permisos de sesión antes de un tiempo específico
<a name="revoke-session-policy"></a>

 También puede revocar los permisos de sesión en el momento que elija mediante el AWS CLI o el SDK para especificar un valor para la `aws:TokenIssueTime` clave en el elemento Condición de una política. 

Esta política deniega todos los permisos cuando el valor de `aws:TokenIssueTime` es anterior a la fecha y la hora especificadas. El valor de `aws:TokenIssueTime` corresponde al intervalo de tiempo exacto en el que se han creado las credenciales de seguridad temporales. El valor de `aws:TokenIssueTime` solo está presente en el contexto de las solicitudes de AWS que se firman con credenciales de seguridad temporales, de modo que la instrucción de denegación de la política no afecta a las solicitudes que se firman con las credenciales a largo plazo del usuario de IAM.

Esta política también puede asociarse a un rol. En tal caso, la política solo afecta a las credenciales de seguridad temporales que el rol ha creado antes de la fecha y la hora especificadas.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Deny",
    "Action": "*",
    "Resource": "*",
    "Condition": {
      "DateLessThan": {"aws:TokenIssueTime": "2014-05-07T23:47:00Z"}
    }
  }
}
```

------

Los usuarios válidos cuyas sesiones se revocan de esta forma deben obtener credenciales temporales para una nueva sesión para poder seguir trabajando. Las credenciales de caché de la AWS CLI hasta que caducan. Para obligar a la CLI a eliminar y actualizar las credenciales en caché que ya no son válidas, ejecute uno de los comandos siguientes:

**Linux, macOS o Unix**

```
$ rm -r ~/.aws/cli/cache
```

**Windows**

```
C:\> del /s /q %UserProfile%\.aws\cli\cache
```

# Actualizar un rol vinculado a servicios
<a name="id_roles_update-service-linked-role"></a>

El método que utilice para editar roles vinculados a servicios depende del servicio. Algunos servicios le permiten editar los permisos de un rol vinculado a un servicio desde la consola, la API o la CLI. Sin embargo, después de crear un rol vinculado a un servicio, no puede cambiarle el nombre, ya que que varias entidades pueden hacer referencia al rol. Puede editar la descripción de cualquier rol desde la consola, la API o la CLI de IAM.

Para obtener información sobre los servicios que admiten el uso de roles vinculados a servicios, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md) y busque los servicios que tengan **Yes **en la columna **Service-Linked Role**. Para saber si el servicio admite la edición de roles vinculados al servicio mismo, haga clic en el enlace **Yes (Sí)** para consultar la documentación relacionada con los roles vinculados a dicho servicio.

## Editar la descripción de un rol vinculado a un servicio (consola)
<a name="edit-service-linked-role-iam-console"></a>

Puede utilizar la consola de IAM para editar la descripción de un rol vinculado a un servicio.

**Para editar la descripción de un rol vinculado a un servicio (consola)**

1. En el panel de navegación de la consola de IAM, elija **Roles**.

1. Seleccione el nombre del rol que desea modificar.

1. En el extremo derecho de **Role description**, seleccione **Edit**. 

1. Ingrese una descripción nueva en el cuadro **Save** (Guardar).

## Edición de la descripción de un rol vinculado a servicio (AWS CLI)
<a name="edit-service-linked-role-iam-cli"></a>

Puede utilizar comandos de IAM desde la AWS CLI para editar la descripción de un rol vinculado a un servicio.

**Para cambiar la descripción de un rol vinculado a un servicio (AWS CLI)**

1. (Opcional) Para ver la descripción actual de un rol, ejecute los siguientes comandos:

   ```
   aws iam [get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html) --role-name ROLE-NAME
   ```

   Utilice el nombre del rol, no el ARN, para hacer referencia a los roles con los comandos de CLI. Por ejemplo, si un rol tiene el ARN `arn:aws:iam::123456789012:role/myrole`, debe referirse a él como **myrole**.

1. Para actualizar la descripción de un rol vinculado a un servicio, ejecute el siguiente comando:

   ```
   aws iam [update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html) --role-name ROLE-NAME --description OPTIONAL-DESCRIPTION
   ```

## Edición de la descripción de una función vinculada a servicio (API de AWS)
<a name="edit-service-linked-role-iam-api"></a>

Puede utilizar la API de AWS para editar la descripción de un rol vinculado a un servicio.

**Para cambiar la descripción de un rol vinculado a un servicio (API de AWS)**

1. (Opcional) Para ver la descripción actual de un rol, llame a la siguiente operación y especifique el nombre del rol:

   API de AWS: [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Para actualizar la descripción de un rol, llame a la siguiente operación y especifique el nombre (y opcionalmente, una descripción) del rol: 

   API de AWS: [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html) 

# Actualizar una política de confianza de rol
<a name="id_roles_update-role-trust-policy"></a>

Para cambiar quién puede asumir un rol, debe modificar la política de confianza del rol. No se puede modificar la política de confianza de un *[rol vinculado a un servicio](id_roles.md#iam-term-service-linked-role)*.

**Notas**  
Si un usuario identificado como entidad principal de una política de confianza de un rol no puede asumir ese rol, compruebe el [límite de permisos](access_policies_boundaries.md) del usuario. Si hay definido un límite de permisos para el usuario, el límite deberá permitir la acción `sts:AssumeRole`.
Para permitir que los usuarios vuelvan a asumir el rol actual dentro de una sesión de rol, especifique el ARN del rol o el ARN de la Cuenta de AWS como entidad principal en la política de confianza de rol. Los Servicios de AWS que proporcionan recursos de computación, como Amazon EC2, Amazon ECS, Amazon EKS y Lambda, brindan credenciales temporales y las actualizan automáticamente. Esto garantiza que siempre disponga de un conjunto de credenciales válido. Para estos servicios, no es necesario volver a asumir el rol actual a fin de obtener credenciales temporales. Sin embargo, si tiene la intención de aprobar [etiquetas de sesión](id_session-tags.md) o una [política de sesión](access_policies.md#policies_session), tendrá que volver a asumir el rol actual.


## Actualización de una política de confianza de rol (consola)
<a name="id_roles_update-trust-policy-console"></a>

**Cambio de una política de confianza de rol en la Consola de administración de AWS**

1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación de la consola de IAM, elija **Roles**.

1. En la lista de roles de su cuenta, elija el nombre del rol que desee modificar.

1. Elija la pestaña **Relaciones de confianza** y, a continuación, **Editar política de confianza**.

1. Edite la política de confianza según sea necesario. Para añadir entidades principales adicionales que puedan asumir el rol, especifíquelas en el elemento `Principal`. Por ejemplo, el siguiente fragmento de política muestra cómo hacer referencia a dos Cuentas de AWS en el elemento `Principal`:

   ```
   "Principal": {
     "AWS": [
       "arn:aws:iam::111122223333:root",
       "arn:aws:iam::444455556666:root"
     ]
   },
   ```

   Si especifica una entidad principal de otra cuenta, el hecho de añadir una cuenta a la política de confianza de un rol solo es una parte del establecimiento de una relación de confianza entre cuentas. De forma predeterminada, ningún usuario de las cuentas de confianza puede asumir el rol. El administrador de la cuenta en la que se acaba de establecer la relación de confianza debe conceder a los usuarios permiso para asumir el rol. Para ello, el administrador debe crear o editar una política que esté asociada al usuario para permitirle a este el acceso a la acción `sts:AssumeRole`. Para obtener más información, consulte el siguiente procedimiento o [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).

   El siguiente fragmento de política muestra cómo hacer referencia a dos servicios de AWS en el elemento `Principal`:

   ```
   "Principal": {
     "Service": [
       "opsworks.amazonaws.com",
       "ec2.amazonaws.com"
     ]
   },
   ```

1. Cuando haya terminado de editar la política de confianza, elija **Update policy** (Actualizar política) para guardar los cambios.

   Para obtener más información sobre la estructura y la sintaxis de la política, consulte las secciones [Políticas y permisos en AWS Identity and Access Management](access_policies.md) y [Referencia de los elementos de la política de JSON de IAM](reference_policies_elements.md).

**Para permitir que los usuarios de una cuenta externa de confianza utilicen el rol (consola)**

Para obtener más información y detalles sobre este procedimiento, consulte [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).

1. Inicie sesión en la Cuenta de AWS externa de confianza. 

1. Decida si desea asociar los permisos a un usuario o a un grupo. En el panel de navegación de la consola de IAM, elija **Users** (Usuarios) o **User groups** (Grupos de usuarios) según corresponda.

1. Elija el nombre del usuario o el grupo al que desea conceder acceso y, a continuación, elija la pestaña **Permissions (Permisos)**.

1. Realice una de las siguientes acciones:
   + Para editar una política administrada por el cliente, elija el nombre de la política, elija **Edit policy (Editar política)** y, a continuación, elija la pestaña **JSON**. No se puede editar una política administrada por AWS. Las políticas administradas de AWS aparecen con el icono AWS (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/policy_icon.png)). Para obtener más información acerca de la diferencia entre las políticas administradas por AWS y las políticas administradas por el cliente, consulte [Políticas administradas y políticas insertadas](access_policies_managed-vs-inline.md).
   + Para editar una política insertada, seleccione la flecha que aparece junto al nombre de la política y elija **Edit Policy (Editar política)**.

1. En el editor de políticas, añada un elemento `Statement` nuevo que especifique lo siguiente:

   ```
   {
     "Effect": "Allow",
     "Action": "sts:AssumeRole",
     "Resource": "arn:aws:iam::ACCOUNT-ID:role/ROLE-NAME"
   }
   ```

   Reemplace el ARN de la instrucción por el ARN del rol que el usuario puede asumir.

1. Siga las indicaciones que aparecen en pantalla para terminar de editar la política. 

## Actualización de una política de confianza de rol (AWS CLI)
<a name="id_roles-update-trust-policy-cli"></a>

Puede utilizar la AWS CLI para cambiar quién puede asumir un rol.

**Para modificar una política de confianza de rol (AWS CLI)**

1. (Opcional) Si no conoce el nombre del rol que desea modificar, ejecute el siguiente comando para ver una lista de los roles de la cuenta:
   + [aws iam list-roles](https://docs.aws.amazon.com/cli/latest/reference/iam/list-roles.html)

1. (Opcional) Para ver la política de confianza actual de un rol, ejecute el siguiente comando:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Para modificar las entidades principales de confianza que pueden obtener acceso al rol, cree un archivo de texto con la política de confianza actualizada. Puede utilizar cualquier editor de texto para crear la política.

   Por ejemplo, la política de confianza siguiente muestra cómo hacer referencia a dos Cuentas de AWS en el elemento `Principal`. Esto permite a los usuarios de dos Cuentas de AWS independientes asumir este rol.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Principal": {"AWS": [
               "arn:aws:iam::111122223333:root",
               "arn:aws:iam::444455556666:root"
           ]},
           "Action": "sts:AssumeRole"
       }
   }
   ```

------

   Si especifica una entidad principal de otra cuenta, el hecho de añadir una cuenta a la política de confianza de un rol solo es una parte del establecimiento de una relación de confianza entre cuentas. De forma predeterminada, ningún usuario de las cuentas de confianza puede asumir el rol. El administrador de la cuenta en la que se acaba de establecer la relación de confianza debe conceder a los usuarios permiso para asumir el rol. Para ello, el administrador debe crear o editar una política que esté asociada al usuario para permitirle a este el acceso a la acción `sts:AssumeRole`. Para obtener más información, consulte el siguiente procedimiento o [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).

1. Si desea utilizar el archivo que acaba de crear para actualizar la política de confianza, ejecute el siguiente comando:
   + [aws iam update-assume-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/update-assume-role-policy.html)

**Para permitir que los usuarios de una cuenta externa de confianza utilicen el rol (AWS CLI)**

Para obtener más información y detalles sobre este procedimiento, consulte [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).

1. Cree un archivo JSON que contenga una política de permisos que conceda permisos para asumir el rol. Por ejemplo, la política siguiente contiene los permisos mínimos necesarios:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Action": "sts:AssumeRole",
           "Resource": "arn:aws:iam::111122223333:role/ROLE-NAME"
       }
   }
   ```

------

   Reemplace el ARN de la instrucción por el ARN del rol que el usuario puede asumir.

1. Ejecute el siguiente comando para cargar el archivo JSON que contiene la política de confianza en IAM:
   + [aws iam create-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html)

   La salida de este comando incluye el ARN de la política. Anote este ARN, ya que tendrá que utilizarlo en un paso posterior. 

1. Decida a qué usuario o grupo asociará la política. Si no conoce el nombre del usuario o el grupo en cuestión, ejecute uno de los comandos siguientes para mostrar una lista de los usuarios o grupos de la cuenta:
   + [aws iam list-users](https://docs.aws.amazon.com/cli/latest/reference/iam/list-users.html)
   + [aws iam list-groups](https://docs.aws.amazon.com/cli/latest/reference/iam/list-groups.html)

1. Ejecute uno de los siguientes comandos para asociar la política que ha creado en el paso anterior al usuario o al grupo:
   + [aws iam attach-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html)
   + [aws iam attach-group-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-group-policy.html)

## Actualización de una política de confianza de rol (API de AWS)
<a name="id_roles-update-trust-policy-api"></a>

Puede utilizar la API de AWS para cambiar quién puede asumir un rol.

**Para modificar una política de confianza de rol (API de AWS)**

1. (Opcional) Si no conoce el nombre del rol que desea modificar, llame a la siguiente operación para ver una lista de los roles de la cuenta:
   + [ListRoles](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRoles.html)

1. (Opcional) Para ver la política de confianza actual de un rol, llame a la siguiente operación:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)

1. Para modificar las entidades principales de confianza que pueden obtener acceso al rol, cree un archivo de texto con la política de confianza actualizada. Puede utilizar cualquier editor de texto para crear la política.

   Por ejemplo, la política de confianza siguiente muestra cómo hacer referencia a dos Cuentas de AWS en el elemento `Principal`. Esto permite a los usuarios de dos Cuentas de AWS independientes asumir este rol.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Principal": {"AWS": [
               "arn:aws:iam::111122223333:root",
               "arn:aws:iam::444455556666:root"
           ]},
           "Action": "sts:AssumeRole"
       }
   }
   ```

------

   Si especifica una entidad principal de otra cuenta, el hecho de añadir una cuenta a la política de confianza de un rol solo es una parte del establecimiento de una relación de confianza entre cuentas. De forma predeterminada, ningún usuario de las cuentas de confianza puede asumir el rol. El administrador de la cuenta en la que se acaba de establecer la relación de confianza debe conceder a los usuarios permiso para asumir el rol. Para ello, el administrador debe crear o editar una política que esté asociada al usuario para permitirle a este el acceso a la acción `sts:AssumeRole`. Para obtener más información, consulte el siguiente procedimiento o [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).

1. Si desea utilizar el archivo que acaba de crear para actualizar la política de confianza, llame a la operación siguiente:
   + [UpdateAssumeRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAssumeRolePolicy.html)

**Para permitir que los usuarios de una cuenta externa de confianza utilicen el rol (API de AWS)**

Para obtener más información y detalles sobre este procedimiento, consulte [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).

1. Cree un archivo JSON que contenga una política de permisos que conceda permisos para asumir el rol. Por ejemplo, la política siguiente contiene los permisos mínimos necesarios:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": {
           "Effect": "Allow",
           "Action": "sts:AssumeRole",
           "Resource": "arn:aws:iam::111122223333:role/ROLE-NAME"
       }
   }
   ```

------

   Reemplace el ARN de la instrucción por el ARN del rol que el usuario puede asumir.

1. Llame a la operación siguiente para cargar el archivo JSON que contiene la política de confianza en IAM:
   + [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)

   La salida de esta operación incluye el ARN de la política. Anote este ARN, ya que tendrá que utilizarlo en un paso posterior. 

1. Decida a qué usuario o grupo asociará la política. Si no conoce el nombre del usuario o el grupo en cuestión, llame a una de las operaciones siguientes para mostrar una lista de los usuarios o grupos de la cuenta:
   + [ListUsers](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUsers.html)
   + [ListGroups](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListGroups.html)

1. Llame a una de las operaciones siguientes para asociar la política que ha creado en el paso anterior al usuario o al grupo:
   +  API: [AttachUserPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachUserPolicy.html)
   + [AttachGroupPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachGroupPolicy.html)

# Actualización de los permisos de un rol
<a name="id_roles_update-role-permissions"></a>

Utilice los siguientes procedimientos para actualizar las políticas y los límites de permisos de un rol.

## Requisito previo: ver el acceso del rol
<a name="roles-modify_prerequisites"></a>

Antes de cambiar los permisos para un rol, debe revisar su actividad de nivel de servicio reciente. Esto es importante porque no desea eliminar el acceso de un principal (persona o aplicación) que está utilizándolo. Para obtener más información acerca de cómo ver la información de acceso reciente, consulte [Ajuste de permisos en AWS con información sobre los últimos accesos](access_policies_last-accessed.md).

## Actualizar la política de permisos para un rol
<a name="id_roles_update-role-permissions-policy"></a>

Para cambiar los permisos permitidos por el rol, modifique la política (o políticas) de permisos del rol. No se puede modificar la política de permisos de un *[rol vinculado a un servicio](id_roles.md#iam-term-service-linked-role)* en IAM. Se podría modificar la política de permisos en el servicio que depende del rol. Para comprobar si un servicio admite esta característica, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md) y busque los servicios con **Sí **en la columna **Roles vinculados a servicios**. Elija una opción **Sí** con un enlace para ver la documentación acerca del rol vinculado al servicio en cuestión.

### Actualización de una política de permisos de rol (consola)
<a name="id_roles_update-role-permissions-policy-console"></a>

**Para cambiar los permisos de un rol (consola)**

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación de la consola de IAM, elija **Roles**.

1. Elija el nombre del rol que desea modificar y, a continuación, la pestaña **Permissions (Permisos)**.

1. Realice una de las siguientes acciones:
   + Para editar una política administrada por el cliente ya existente, elija el nombre de la política y seleccione **Edit policy (Editar política)**.
**nota**  
No se puede editar una política administrada por AWS. Las políticas administradas de AWS aparecen con el icono AWS (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/policy_icon.png)). Para obtener más información acerca de la diferencia entre las políticas administradas por AWS y las políticas administradas por el cliente, consulte [Políticas administradas y políticas insertadas](access_policies_managed-vs-inline.md). 
   + Para asociar una política administrada existente al rol, elija **Add permissions** (Agregar permisos) y luego **Attach policies** (Asociar políticas).
   + Para editar una política insertada existente, expándala y elija **Edit** (Editar).
   + Para integrar una nueva política insertada, elija **Add permissions** (Agregar permisos) y luego **Create inline policy** (Crear política insertada). 
   + Para eliminar una política existente del rol, seleccione la casilla de verificación que se encuentra junto al nombre de la política y, a continuación, elija **Eliminar**.

### Actualización de una política de permisos de rol (AWS CLI)
<a name="id_roles_update_permissions-policy-cli"></a>

Para cambiar los permisos permitidos por el rol, modifique la política (o políticas) de permisos del rol. No se puede modificar la política de permisos de un *[rol vinculado a un servicio](id_roles.md#iam-term-service-linked-role)* en IAM. Se podría modificar la política de permisos en el servicio que depende del rol. Para comprobar si un servicio admite esta característica, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md) y busque los servicios con **Sí **en la columna **Roles vinculados a servicios**. Elija una opción **Sí** con un enlace para ver la documentación acerca del rol vinculado al servicio en cuestión.

**Para cambiar los permisos que permite un rol (AWS CLI)**

1. (Opcional) Para ver los permisos actuales asociados a un rol, ejecute los siguientes comandos:

   1. [aws iam list-role-policies](https://docs.aws.amazon.com/cli/latest/reference/iam/list-role-policies.html) para obtener una lista de políticas insertadas

   1. [aws iam list-attached-role-policies](https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-role-policies.html) para obtener una lista de políticas administradas

1. El comando para actualizar los permisos del rol varía en función de si se está actualizando una política administrada o una política insertada.

   Para actualizar una política administrada, ejecute el siguiente comando para crear una nueva versión de la política administrada:
   + [aws iam create-policy-version](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy-version.html)

   Para actualizar una política insertada, ejecute el siguiente comando:
   + [aws iam put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

### Actualización de una política de permisos de rol (API de AWS)
<a name="id_roles_update_permissions-policy-api"></a>

Para cambiar los permisos permitidos por el rol, modifique la política (o políticas) de permisos del rol. No se puede modificar la política de permisos de un *[rol vinculado a un servicio](id_roles.md#iam-term-service-linked-role)* en IAM. Se podría modificar la política de permisos en el servicio que depende del rol. Para comprobar si un servicio admite esta característica, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md) y busque los servicios con **Sí **en la columna **Roles vinculados a servicios**. Elija una opción **Sí** con un enlace para ver la documentación acerca del rol vinculado al servicio en cuestión.

**Para cambiar los permisos que permite un rol (API de AWS)**

1. (Opcional) Para ver los permisos actuales asociados a un rol, llame a las siguientes operaciones:

   1. [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html) para obtener una lista de políticas insertadas

   1. [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html) para obtener una lista de políticas administradas

1. La operación para actualizar los permisos del rol varía en función de si se está actualizando una política administrada o una política insertada.

   Para actualizar una política administrada, llame a la siguiente operación para crear una nueva versión de la política administrada:
   + [CreatePolicyVersion](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicyVersion.html)

   Para actualizar una política insertada, llame a la siguiente operación:
   + [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

## Actualizar el límite de permisos para un rol
<a name="id_roles_update-role-permissions-boundary"></a>

Para cambiar los permisos máximos permitidos para un rol, modifique el [límite de permisos](access_policies_boundaries.md) del rol.

### Actualización de un límite de permisos de rol (consola)
<a name="id_roles_update-permissions-boundary-console"></a>

**Para cambiar la política que se utiliza para establecer el límite de permisos de un rol**

1. Inicie sesión en Consola de administración de AWS y abra la consola IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Seleccione **Roles** en el panel de navegación.

1. Elija el nombre del rol con el [límite de permisos](access_policies_boundaries.md) que desea modificar. 

1. Elija la pestaña **Permisos**. Si es necesario, abra la sección **Permissions boundary (Límite de permisos)** y, a continuación, elija **Change boundary (Cambiar límite)**.

1. Seleccione la política que desea utilizar para el límite de permisos.

1. Elija **Change boundary (Cambiar límite)**.

   Los cambios no entrarán en vigor hasta la próxima vez que alguien asuma este rol.

### Actualización de un límite de permisos de rol (AWS CLI)
<a name="id_roles_update_permissions-boundary-cli"></a>

**Para cambiar la política administrada que se utiliza para establecer el límite de permisos de un rol (AWS CLI)**

1. (Opcional) Para ver el [límite de permisos](access_policies_boundaries.md) actual de un rol, ejecute el comando siguiente: 
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Si desea utilizar una política administrada diferente para actualizar el límite de permisos de un rol, ejecute el comando siguiente: 
   + [aws iam put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Un rol solo puede tener una política administrada configurada como límite de permisos. Si cambia el límite de permisos, también cambiará los permisos que puede tener un rol como máximo.

### Actualización de un límite de permisos de rol (API de AWS)
<a name="id_roles_update-permissions-boundary-api"></a>

**Para cambiar la política administrada que se utiliza para establecer el límite de permisos de un rol (API de AWS)**

1. (Opcional) Para ver el [límite de permisos](access_policies_boundaries.md) actual de un rol, llame a la operación siguiente: 
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)

1. Si desea utilizar una política administrada diferente para actualizar el límite de permisos de un rol, llame a la operación siguiente: 
   + [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Un rol solo puede tener una política administrada configurada como límite de permisos. Si cambia el límite de permisos, también cambiará los permisos que puede tener un rol como máximo.

# Actualización de la configuración de un rol
<a name="id_roles_update-role-settings"></a>

Utilice los siguientes procedimientos para actualizar la descripción de un rol o cambiar la duración máxima de la sesión para un rol.

## Actualizar una descripción de rol
<a name="id_roles_update-description"></a>

Para cambiar la descripción del rol, modifique el texto de descripción.

### Actualización de una descripción de rol (consola)
<a name="id_roles_update-description-console"></a>

**Para cambiar la descripción del rol (consola)**

1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación de la consola de IAM, elija **Roles**.

1. Seleccione el nombre del rol que desea modificar.

1. En la sección **Summary** (Resumen), elija **Edit** (Editar).

1. Ingrese una descripción nueva en el cuadro y elija **Save changes** (Guardar cambios).

### Actualización de una descripción de rol (AWS CLI)
<a name="id_roles_update-description-cli"></a>

**Para cambiar la descripción de un rol (AWS CLI)**

1. (Opcional) Para ver la descripción actual de un rol, ejecute el siguiente comando:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Para actualizar la descripción de un rol, ejecute el siguiente comando con el parámetro de descripción:
   + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html)

### Actualización de una descripción de rol (API de AWS)
<a name="id_roles_update-description-api"></a>

**Para cambiar la descripción de un rol (API de AWS)**

1. (Opcional) Para ver la descripción actual de un rol, llame a la siguiente operación:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Para actualizar la descripción de un rol, llame a la siguiente operación con el parámetro de descripción:
   + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html)

## Actualizar la duración máxima de la sesión para un rol
<a name="id_roles_update-session-duration"></a>

Para especificar la duración máxima de la sesión para los roles que se asumen mediante la consola, AWS CLI o la API de AWS, modifique el valor del ajuste de duración máxima de la sesión. Esta opción puede tener un valor comprendido entre 1 y 12 horas. Si no especifica un valor, se aplicará el valor máximo predeterminado de 1 hora. Esta configuración no limita las sesiones asumidas por los servicios de AWS.

### Actualización de la duración máxima de la sesión de un rol (consola)
<a name="id_roles_update-session-duration-console"></a><a name="id_roles_modify_max-session"></a>

**Para cambiar el valor de la duración máxima de la sesión para los roles que se asumen mediante la consola, AWS CLI o la API de AWS (consola)**

1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación de la consola de IAM, elija **Roles**.

1. Seleccione el nombre del rol que desea modificar.

1. En la sección **Summary** (Resumen), elija **Edit** (Editar).

1. En **Maximum session duration** (Duración máxima de la sesión), elija un valor. Como alternativa, puede elegir **Custom duration** (Duración personalizada) e ingresar un valor (en segundos).

1. Seleccione **Save changes (Guardar cambios)**.

   Los cambios no entrarán en vigor hasta la próxima vez que alguien asuma este rol. Para obtener información sobre cómo revocar sesiones existentes para este rol, consulte [Revocación de las credenciales de seguridad temporales de un rol de IAM](id_roles_use_revoke-sessions.md).

En Consola de administración de AWS, las sesiones de usuario de IAM son de 12 horas de forma predeterminada. A los usuarios de IAM que cambian de rol en la consola se les concede la duración máxima de la sesión del rol, o el tiempo restante de la sesión del usuario, lo que sea menor.

Cualquier persona que asuma el rol desde el AWS CLI o la API de AWS puede solicitar una sesión más larga, hasta este máximo. El ajuste de la `MaxSessionDuration` determina la duración máxima de la sesión de rol que se puede solicitar.
+ Para especificar una duración de sesión utilizando el AWS CLI utilice el parámetro `duration-seconds`. Para obtener más información, consulte [Cambiar a un rol de IAM (AWS CLI)](id_roles_use_switch-role-cli.md).
+ Para especificar una duración de sesión mediante la API de AWS, utilice el parámetro `DurationSeconds`. Para obtener más información, consulte [Cambiar a un rol de IAM (API de AWS)](id_roles_use_switch-role-api.md). 

### Actualización de la duración máxima de la sesión de un rol (AWS CLI)
<a name="id_roles_update-session-duration-cli"></a>

**nota**  
Cualquiera que asuma el rol desde la API o la AWS CLI puede utilizar el `duration-seconds` parámetro de la CLI o el `DurationSeconds` parámetro de la API para solicitar una sesión más larga. El ajuste `MaxSessionDuration` determina la duración máxima de la sesión de rol que se puede solicitar mediante el parámetro `DurationSeconds`. Si los usuarios no especifican un valor para el parámetro `DurationSeconds`, sus credenciales de seguridad serán válidas durante una hora.

**Para cambiar el valor de la duración máxima de la sesión para los roles que se asumen mediante AWS CLI (AWS CLI)**

1. (Opcional) Para ver el valor actual de la duración máxima de la sesión de un rol, ejecute el siguiente comando:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Para actualizar el valor de la duración máxima de la sesión de un rol, ejecute el siguiente comando con el parámetro `max-session-duration` de la CLI o el parámetro `MaxSessionDuration` de la API:
   + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html)

   Los cambios no entrarán en vigor hasta la próxima vez que alguien asuma este rol. Para obtener información sobre cómo revocar sesiones existentes para este rol, consulte [Revocación de las credenciales de seguridad temporales de un rol de IAM](id_roles_use_revoke-sessions.md).

### Actualización de la duración máxima de la sesión de un rol (API de AWS)
<a name="id_roles_update-session-duration-api"></a>

**nota**  
Cualquiera que asuma el rol desde la API o la AWS CLI puede utilizar el `duration-seconds` parámetro de la CLI o el `DurationSeconds` parámetro de la API para solicitar una sesión más larga. El ajuste `MaxSessionDuration` determina la duración máxima de la sesión de rol que se puede solicitar mediante el parámetro `DurationSeconds`. Si los usuarios no especifican un valor para el parámetro `DurationSeconds`, sus credenciales de seguridad serán válidas durante una hora.

**Para cambiar el valor de la duración máxima de la sesión para los roles que se asumen mediante la API (API de AWS)**

1. (Opcional) Para ver el valor actual de la duración máxima de la sesión de un rol, llame a la siguiente operación:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Para actualizar el valor de la duración máxima de la sesión de un rol, llame a la siguiente operación con el parámetro `max-sessionduration` de la CLI o el parámetro `MaxSessionDuration` de la API:
   + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html)

   Los cambios no entrarán en vigor hasta la próxima vez que alguien asuma este rol. Para obtener información sobre cómo revocar sesiones existentes para este rol, consulte [Revocación de las credenciales de seguridad temporales de un rol de IAM](id_roles_use_revoke-sessions.md).

# Eliminar roles o perfiles de instancia
<a name="id_roles_manage_delete"></a>

Si ya no necesita un rol, le recomendamos que elimine el rol y sus permisos asociados. De esta forma no tiene una entidad no utilizada que no se monitoree ni mantenga de forma activa. 

Si el rol se asoció a una instancia EC2, puede también eliminarlo del perfil de instancia y, a continuación, eliminar dicho perfil.

**aviso**  
Asegúrese de que no tiene ninguna instancia de Amazon EC2 ejecutándose con el rol o el perfil de instancias que va a eliminar. Al eliminar un perfil de instancias o rol asociado a una instancia en ejecución se romperá cualquier aplicación que se esté ejecutando en la instancia.

Si prefiere no eliminar permanentemente un rol, puede deshabilitarlo. Para ello, cambie las políticas del rol y, a continuación, revoque todas las sesiones actuales. Por ejemplo, podría añadir una política al rol que denegó el acceso a todos de AWS. También puede editar la política de confianza para denegar el acceso a cualquier persona que intente asumir el rol. Para obtener más información acerca de cómo revocar sesiones, consulte [Revocación de las credenciales de seguridad temporales de un rol de IAM](id_roles_use_revoke-sessions.md).

**Topics**
+ [

## Visualización del acceso a los roles
](#roles-delete_prerequisites)
+ [

## Eliminar un rol vinculado a un servicio
](#id_roles_manage_delete_slr)
+ [

## Eliminar un rol de IAM (consola)
](#roles-managingrole-deleting-console)
+ [

## Eliminar un rol de IAM (AWS CLI)
](#roles-managingrole-deleting-cli)
+ [

## Eliminar un rol de IAM (API de AWS)
](#roles-managingrole-deleting-api)
+ [

## Información relacionada
](#roles-managingrole-deleting-related-info)

## Visualización del acceso a los roles
<a name="roles-delete_prerequisites"></a>

Antes de eliminar un rol, le recomendamos que revise la fecha en que se usó el rol por última vez. Para ello, utilice la Consola de administración de AWS, la AWS CLI o la API de AWS. Debe ver esta información porque no debería eliminar el acceso de alguien que utilice el rol. 

Es posible que la fecha de la última actividad del rol no coincida con la última fecha notificada en la pestaña de **Último acceso**. La pestaña de [**Último acceso**](access_policies_last-accessed-view-data.md) informa la actividad solo para los servicios permitidos por las políticas de permisos del rol. La fecha de la última actividad del rol incluye el último intento de acceder a cualquier servicio de AWS.

**nota**  
El periodo de seguimiento de la última actividad de un rol y los datos del Último acceso es para los últimos 400 días. Este período puede ser más corto si su Región comenzó a admitir estas características en el último año. El rol podría haberse utilizado hace más de 400 días. Para obtener más información sobre el período de seguimiento, consulte [Dónde AWS se hace un seguimiento de la información de acceso reciente](access_policies_last-accessed.md#last-accessed_tracking-period).

**Para ver cuándo se utilizó un rol por última vez (consola)**

1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Seleccione **Roles** en el panel de navegación.

1. Busque la fila del rol con la actividad que desee ver. Puede utilizar el campo de búsqueda para filtrar los resultados. Vea la columna **Última actividad** para ver el número de días transcurridos desde la última vez que se utilizó el rol. Si el rol no se ha utilizado dentro del período de seguimiento, la tabla muestra **Ninguno**. 

1. Elija el nombre del rol para ver más información. La página **Resumen** del rol también incluye **Última actividad**, que muestra la fecha en que se utilizó el rol por última vez. Si el rol no se ha utilizado en los últimos 400 días, **Última actividad** muestra **No se ha accedido en el período de seguimiento**.

**Para ver cuándo se utilizó un rol por última vez (AWS CLI)**  
`[aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)` - Ejecute este comando para devolver información sobre un rol, incluido el objeto `RoleLastUsed`. Este objeto contiene el `LastUsedDate` y el `Region` en el que se utilizó el rol por última vez. Si `RoleLastUsed` está presente pero no contiene un valor, el rol no se ha utilizado dentro del período de seguimiento.

**Para ver cuándo se usó un rol por última vez (AWS API)**  
`[GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/GetRole.html)` - Llame a esta operación para devolver información sobre un rol, incluido el objeto `RoleLastUsed`. Este objeto contiene el `LastUsedDate` y el `Region` en el que se utilizó el rol por última vez. Si `RoleLastUsed` está presente pero no contiene un valor, el rol no se ha utilizado dentro del período de seguimiento.

## Eliminar un rol vinculado a un servicio
<a name="id_roles_manage_delete_slr"></a>

El método que utilice para eliminar roles vinculados a servicios depende del servicio. En algunos casos, no es necesario eliminar manualmente roles vinculados a servicios. Por ejemplo, al finalizar una acción específica (por ejemplo, retirar un recurso) en el servicio, este puede eliminar el rol vinculado al servicio en su nombre. En otros casos, el servicio podría admitir la eliminación manual de un rol vinculado al servicio mismo desde su consola, la API o la AWS CLI. 

Revise la documentación del *[rol vinculado a servicios](id_roles.md#iam-term-service-linked-role)* en el servicio vinculado para obtener información sobre cómo eliminar el rol. Puede consultar los roles vinculados a servicios en su cuenta en cualquier momento a través de la página de IAM **Roles** de la consola. Los roles vinculados con servicios aparecen con el texto **(Service-linked role (Función vinculada al servicio))** en la columna **Trusted entities (Entidades de confianza)** de la tabla. Un banner en la página **Resumen** del rol también indica que es un tipo de rol vinculado a un servicio.

Si el servicio no incluye documentación acerca de cómo eliminar el rol vinculado al servicio, puede utilizar la consola de IAM, la AWS CLI o la API para eliminarlo.

## Eliminar un rol de IAM (consola)
<a name="roles-managingrole-deleting-console"></a>

Cuando se utiliza la Consola de administración de AWS para eliminar un rol, IAM elimina automáticamente las políticas administradas asociadas al rol. También elimina automáticamente cualquier política en línea asociada con el rol y cualquier perfil de instancia de Amazon EC2 que contenga el rol. 

**importante**  
En algunos casos, un rol podría estar asociado a un perfil de instancias de Amazon EC2 y tanto el rolo como el perfil de instancias podrían tener el mismo nombre. En ese caso, puede utilizar la Consola de administración de AWS para eliminar el rol y el perfil de instancia. Este vínculo se produce de forma automática para roles y perfiles de instancia que crea en la consola. Si creó el rol desde la API de AWS CLI, Tools for Windows PowerShell o API de AWS, el rol y el perfil de instancias podrían tener distintos nombres. En ese caso no puede utilizar la consola para eliminarlos. En cambio, debe utilizar la API de AWS CLI, Tools for Windows PowerShell o API de AWS para primero eliminar el rol del perfil de instancias. A continuación, debe realizar un paso independiente para eliminar el rol.

**Para eliminar un rol (consola)**

1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación, elija **Roles** y, a continuación, seleccione la casilla de verificación junto al nombre del rol que desee eliminar. 

1. En la parte superior de la página, elija **Eliminar**.

1. En el cuadro de diálogo de confirmación, revise la información de acceso reciente, donde se indica cuándo accedió cada uno de los roles seleccionados a un servicio de AWS por última vez. Esto le ayuda a confirmar si el rol está actualmente activo. Si desea continuar, escriba el nombre del rol en el campo de entrada de texto y elija **Eliminar**. Si está seguro, puede continuar con la eliminación, aunque la información de acceso reciente siga cargándose.

**nota**  
No puede utilizar la consola para eliminar un perfil de instancia, a no ser que tenga el mismo nombre que el rol. El perfil de instancias se elimina como parte del proceso de eliminación de un rol, tal y como se describe en el procedimiento anterior. Para eliminar un perfil de instancia sin eliminar también el rol, debe utilizar la AWS CLI o la API de AWS. Para obtener más información, consulte las siguientes secciones.

## Eliminar un rol de IAM (AWS CLI)
<a name="roles-managingrole-deleting-cli"></a>

Cuando utiliza la AWS CLI para eliminar un rol, antes debe eliminar las políticas insertadas asociadas al rol. También debe desvincular las políticas administradas asociadas al rol. Si desea eliminar el perfil de instancia asociado que incluye el rol, debe eliminarlo por separado.

**Para eliminar un rol (AWS CLI)**

1. Si no conoce el nombre del rol que desea eliminar, escriba el siguiente comando para enumerar los roles de su cuenta:

   ```
   aws iam list-roles
   ```

   La lista incluye el Nombre de recurso de Amazon (ARN) de cada rol. Utilice el nombre del rol, no el ARN, para hacer referencia a los roles con los comandos de CLI. Por ejemplo, si un rol tiene el ARN `arn:aws:iam::123456789012:role/myrole`, debe referirse a él como **myrole**.

1. Elimine el rol de todos los perfiles de instancia en los que está asociado.

   1. Para enumerar todos los perfiles de instancia con los que se asocia el rol, escriba el siguiente comando:

      ```
      aws iam list-instance-profiles-for-role --role-name role-name
      ```

   1. Para eliminar el rol de un perfil de instancia, escriba el siguiente comando para cada perfil de instancia:

      ```
      aws iam remove-role-from-instance-profile --instance-profile-name instance-profile-name --role-name role-name
      ```

1. Elimine todas las políticas asociadas al rol.

   1. Para enumerar todas las políticas insertadas que están en el rol, ingrese el siguiente comando:

      ```
      aws iam list-role-policies --role-name role-name
      ```

   1. Para eliminar cada política insertada del rol, ingrese el siguiente comando para cada política: 

      ```
      aws iam delete-role-policy --role-name role-name --policy-name policy-name
      ```

   1. Para enumerar todas las políticas administradas que están asociadas al rol, ingrese el siguiente comando:

      ```
      aws iam list-attached-role-policies --role-name role-name
      ```

   1. Para desvincular cada política administrada del rol, ingrese el siguiente comando para cada política: 

      ```
      aws iam detach-role-policy --role-name role-name --policy-arn policy-arn
      ```

1. Escriba el comando siguiente para eliminar el rol:

   ```
   aws iam delete-role --role-name role-name
   ```

1. Si no tiene pensado reutilizar los perfiles de instancia que se asociaron al rol, puede escribir el siguiente comando para eliminarlos:

   ```
   aws iam delete-instance-profile --instance-profile-name instance-profile-name
   ```

## Eliminar un rol de IAM (API de AWS)
<a name="roles-managingrole-deleting-api"></a>

Si utiliza la API de IAM para eliminar un rol, antes debe eliminar las políticas insertadas asociadas al rol. También debe desvincular las políticas administradas asociadas al rol. Si desea eliminar el perfil de instancia asociado que incluye el rol, debe eliminarlo por separado.

**Para eliminar un rol (API de AWS)**

1. Para enumerar todos los perfiles de instancia asociados a un rol, llame a [ListInstanceProfilesForRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html).

   Para eliminar el rol de un perfil de instancia, llame a [RemoveRoleFromInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html). Debe transmitir el nombre del rol y el nombre del perfil de instancia. 

   Si no va a volver a utilizar un perfil de instancia que estaba asociado al rol, llame a [DeleteInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html) para eliminarlo.

1. Para enumerar todas las políticas insertadas de un rol, llame a [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html).

   Para eliminar todas las políticas insertadas asociadas al rol, llame a [DeleteRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRolePolicy.html). Debe pasar el nombre del rol y el nombre de la política insertada. 

1. Para enumerar todas las políticas administradas que se encuentran asociadas a un rol, llame a [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html). 

   Para desvincular políticas administradas que se encuentran asociadas al rol, llame a [DetachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html). Debe pasar el nombre del rol y el ARN de la política administrada. 

1. Llame a [DeleteRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRole.html) para eliminar el rol.

## Información relacionada
<a name="roles-managingrole-deleting-related-info"></a>

Para obtener información general sobre los perfiles de instancia, consulte [Utilizar perfiles de instancia](id_roles_use_switch-role-ec2_instance-profiles.md).

Para obtener información general acerca de los roles vinculados a servicios, consulte [Creación de un rol vinculado al servicio](id_roles_create-service-linked-role.md).

# Métodos para asumir un rol
<a name="id_roles_manage-assume"></a>

Para que un usuario, una aplicación o un servicio pueda utilizar un rol creado por usted, debe [conceder permisos para cambiar](id_roles_use_permissions-to-switch.md) al rol. Puede utilizar cualquier política asociada a grupos o usuarios para otorgar los permisos necesarios. Una vez concedidos los permisos, el usuario puede asumir un rol desde la Consola de administración de AWS, las herramientas para Windows PowerShell, la AWS Command Line Interface (AWS CLI) y la API de [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html).

**importante**  
Cuando crea un rol mediante programación en lugar de hacerlo en la consola de IAM, tiene la opción de agregar un `Path` de 512 caracteres como máximo además del `RoleName`, que puede tener un máximo de 64 caracteres. Sin embargo, si desea utilizar un rol con la característica **Cambiar rol** en la consola de Consola de administración de AWS, la combinación de `Path` y `RoleName` no puede superar los 64 caracteres.

El método que utilice para asumir el rol determinará quién puede asumir el rol y cuánto tiempo puede durar la sesión de ese rol. Cuando se utilizan operaciones de la API `AssumeRole*`, el rol de IAM que se asume es el recurso. El usuario o rol que llama a las operaciones de la API `AssumeRole*` es la entidad principal.

En la siguiente tabla, se comparan los métodos para asumir roles.


|  Método para asumir el papel |  **¿Quién puede asumir el rol?**  | **Método para especificar la duración de las credenciales** |  **Duración de las credenciales (mín \$1 máx \$1 predeterminada)**  | 
| --- | --- | --- | --- | 
| Consola de administración de AWS | Usuario o roles¹ (al [cambiar roles](id_roles_use_switch-role-console.md)) | Duración máxima de la sesión en la página de resumen del Rol | 15 min \$1 configuración de la duración máxima de la sesión² \$1 1 h | 
| Operación [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) de la CLI u operación [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) de la API |  Usuario o rol¹ | Parámetro duration-seconds de la CLI o parámetro DurationSeconds de la API | 15 min \$1 configuración de la duración máxima de la sesión² \$1 1 h  | 
| Operación [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html) de la CLI u operación [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html) de la API | Cualquier usuario autenticado mediante SAML | Parámetro duration-seconds de la CLI o parámetro DurationSeconds de la API | 15 min \$1 configuración de la duración máxima de la sesión² \$1 1 h  | 
| Operación [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html) de la CLI u operación [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html) de la API | Cualquier usuario autenticado con OIDC | Parámetro duration-seconds de la CLI o parámetro DurationSeconds de la API | 15 min \$1 configuración de la duración máxima de la sesión² \$1 1 h  | 
| [URL de la consola](id_roles_providers_enable-console-custom-url.md) construida con AssumeRole  | Usuario o rol | Parámetro HTMLSessionDuration en la URL | 15 min \$1 12 h \$1 1 h  | 
| [URL de la consola](id_roles_providers_enable-console-custom-url.md) construida con AssumeRoleWithSAML  | Cualquier usuario autenticado mediante SAML | Parámetro HTMLSessionDuration en la URL | 15 min \$1 12 h \$1 1 h | 
| [URL de la consola](id_roles_providers_enable-console-custom-url.md) construida con AssumeRoleWithWebIdentity  | Cualquier usuario autenticado con OIDC | Parámetro HTMLSessionDuration en la URL | 15 min \$1 12 h \$1 1 h  | 

¹ El uso de las credenciales de un rol para asumir un rol se denomina [encadenamiento de roles](id_roles.md#iam-term-role-chaining). Cuando se utiliza el encadenamiento de roles, la sesión del rol tiene una duración máxima de una hora. Esto se aplica al cambio de roles de la Consola de administración de AWS, la AWS CLI y las operaciones de la API. Esta limitación no se aplica a la suposición inicial de un rol mediante las credenciales de usuario ni a las aplicaciones que se ejecutan en las instancias de Amazon EC2 con el uso de los perfiles de instancia.

² Esta opción puede tener un valor comprendido entre 1 y 12 horas. Para obtener información detallada sobre modificar la configuración de la duración máxima de la sesión, consulte [Administración de roles de IAM](id_roles_manage.md). Este ajuste determina la duración máxima de la sesión que se puede solicitar al obtener las credenciales del rol. Por ejemplo, cuando utilice las operaciones [AssumeRole\$1](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) de la API para asumir un rol, puede utilizar el parámetro `DurationSeconds` para especificar la duración de la sesión. Use este parámetro para especificar la duración de la sesión de rol, que puede oscilar entre 900 segundos (15 minutos) y el valor de la duración máxima de la sesión especificado para el rol. A los usuarios de IAM que cambian de rol en la consola se les concede la duración máxima de la sesión, o el tiempo restante de la sesión del usuario, lo que sea menor. Supongamos que establece una duración máxima de 5 horas en un rol. Un usuario de IAM que ha iniciado sesión en la consola durante 10 horas (fuera del máximo predeterminado de 12) cambia al rol. La duración de la sesión de rol disponible es de 2 horas. Para obtener información sobre cómo ver el valor máximo para el rol, consulte [Actualizar la duración máxima de la sesión para un rol](id_roles_update-role-settings.md#id_roles_update-session-duration) más adelante en esta misma página.

**Notas**  
La configuración de duración máxima de sesión no limita las sesiones asumidas por los servicios de AWS.
Las credenciales del rol de IAM de Amazon EC2 no están sujetas a la duración máxima de sesión configurada en el rol.
Para permitir que los usuarios vuelvan a asumir el rol actual dentro de una sesión de rol, especifique el ARN del rol o el ARN de la Cuenta de AWS como entidad principal en la política de confianza de rol. Los Servicios de AWS que proporcionan recursos de computación, como Amazon EC2, Amazon ECS, Amazon EKS y Lambda, brindan credenciales temporales y las actualizan automáticamente. Esto garantiza que siempre disponga de un conjunto de credenciales válido. Para estos servicios, no es necesario volver a asumir el rol actual a fin de obtener credenciales temporales. Sin embargo, si tiene la intención de aprobar [etiquetas de sesión](id_session-tags.md) o una [política de sesión](access_policies.md#policies_session), tendrá que volver a asumir el rol actual. Para obtener información sobre cómo modificar una política de confianza de roles a fin de agregar el ARN del rol o el ARN de la Cuenta de AWS para la entidad principal, consulte [Actualizar una política de confianza de rol](id_roles_update-role-trust-policy.md).

**Topics**
+ [

# Cambiar de usuario a rol de IAM (consola)
](id_roles_use_switch-role-console.md)
+ [

# Cambiar a un rol de IAM (AWS CLI)
](id_roles_use_switch-role-cli.md)
+ [

# Cambiar a un rol de IAM (Herramientas para Windows PowerShell)
](id_roles_use_switch-role-twp.md)
+ [

# Cambiar a un rol de IAM (API de AWS)
](id_roles_use_switch-role-api.md)
+ [

# Utilizar un rol de IAM para conceder permisos a aplicaciones que se ejecutan en instancias de Amazon EC2
](id_roles_use_switch-role-ec2.md)
+ [

# Utilizar perfiles de instancia
](id_roles_use_switch-role-ec2_instance-profiles.md)

# Cambiar de usuario a rol de IAM (consola)
<a name="id_roles_use_switch-role-console"></a>

Solo puede cambiar de rol cuando inicia sesión como usuario de IAM, un usuario en el Centro de Identidades IAM, como rol federado de SAML o como un rol federado de identidad web. Un *rol* especifica un conjunto de permisos que puede utilizar para acceder a los recursos de AWS que necesita. Sin embargo, no inicia sesión en un rol, pero una vez que inicie sesión como un usuario de IAM podrá cambiar a un rol de IAM. Esto anula temporalmente los permisos de usuario originales y, en su lugar, le otorga los permisos asignados al rol. El rol puede estar en su propia cuenta o en cualquier otra Cuenta de AWS. Para obtener más información acerca de los roles, sus ventajas y cómo crearlos, consulte [Roles de IAM](id_roles.md) y [Creación de roles de IAM](id_roles_create.md).

Los permisos de sus usuarios y de cualquier rol al que cambie no se acumulan. Solo hay un conjunto de permisos activo a la vez. Cuando se cambia a un rol, se abandonan temporalmente los permisos de usuario y se trabaja con los permisos que el rol tenga asignados. Al salir del rol, los permisos de usuario se restablecen de forma automática.

Al cambiar de rol en la Consola de administración de AWS, la consola utiliza siempre sus credenciales originales para autorizar el cambio. Por ejemplo, si cambia a RolA, IAM utiliza sus credenciales originales para determinar si puede asumir el RolA. Si luego cambia a RolB, *mientras utiliza el RolA*, AWS seguirá utilizando sus credenciales **originales**, y no las credenciales del RolA, para autorizar el cambio.

**nota**  
Usted asume un rol de IAM cuando inicia sesión como usuario en el IAM Identity Center, como rol federado de SAML o como rol federado de identidades web. Por ejemplo, cuando un usuario del IAM Identity Center inicia sesión en el portal de acceso de AWS, debe elegir un conjunto de permisos que se correlacionen con un rol antes de poder acceder a los recursos de AWS.

## Sesiones de rol
<a name="id_roles_iam_user-switch-role-sessions"></a>

Cuando cambia de rol, de forma predeterminada su sesión en la Consola de administración de AWS dura 1 hora. Las sesiones de usuario de IAM duran 12 horas de forma predeterminada. Es posible que otros usuarios tengan definidas diferentes duraciones de sesión. Cuando cambia de rol en la consola, se le concede una duración máxima de sesión o el tiempo restante de su sesión de usuario (lo que sea menor). Asumir un rol no significa que se extenderá la duración de su sesión.

Por ejemplo, suponga que se establece una duración máxima de sesión de 10 horas para un rol. Su sesión en la consola lleva 8 horas de duración cuando decide cambiar al rol. Quedan 4 horas de su sesión de usuario, por lo que la duración de la sesión permitida para su rol es de 4 horas y no la duración máxima de sesión de 10 horas. En la tabla siguiente se muestra cómo determinar la duración de la sesión para un usuario de IAM al cambiar roles en la consola.


| El tiempo restante de sesión de usuario de IAM es... | La duración de la sesión de rol es… | 
| --- | --- | 
| Duración máxima de la sesión inferior al rol | Tiempo restante en la sesión del usuario | 
| Duración máxima de la sesión mayor al rol | Valor de la duración máxima de la sesión | 
| Igual a la duración máxima de la sesión del rol | Valor de la duración máxima de la sesión (aproximado) | 

Utilizar las credenciales de un rol para asumir otro rol se denomina [encadenamiento de roles](id_roles.md#iam-term-role-chaining). Cuando se utiliza el encadenamiento de roles, se limita la sesión de duración a una hora, sin importar la duración máxima de sesión establecida para cada uno de los roles. Esto se aplica al cambio de roles de la Consola de administración de AWS, la AWS CLI y las operaciones de la API.

**nota**  
Algunas de servicio AWS pueden reiniciar automáticamente su sesión de rol cuando caduque sin que realice ninguna acción. Algunos pueden pedirle que vuelva a cargar la página del navegador para volver a autenticar su sesión.

## Consideraciones
<a name="id_roles_iam_user-switch-role-considerations"></a>
+ Si inicia sesión como Usuario raíz de la cuenta de AWS, no puede cambiar de rol. 
+ Los usuarios deben tener permisos concedidos para cambiar de rol, de acuerdo con la política. Para obtener instrucciones, consulte [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md).
+ En la Consola de administración de AWS, no puede cambiar a un rol que requiera un valor [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id). Solo puede cambiar a dicho rol si llama a la API [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) que admite el parámetro `ExternalId`.

## Para cambiar de rol
<a name="id_roles_iam_user-switch-role-console-procedure"></a>

1. Siga el procedimiento de inicio de sesión apropiado para su tipo de usuario como se describe en [Cómo iniciar sesión en Consola de administración 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*.

1. En la Consola de administración de AWS, elija su nombre de usuario en la barra de navegación que aparece en la parte superior derecha. Normalmente tiene el siguiente aspecto: ***nombre\$1usuario*@*número\$1ID\$1cuenta\$1o\$1alias***.

1. Elija uno de los siguientes métodos para especificar los detalles de la aplicación:
   + Elija **Cambiar rol**.
   + Si optó por el soporte multisesión, elija **Agregar sesión** y seleccione **Cambiar rol**.
**nota**  
Puede iniciar sesión en hasta cinco identidades diferentes al mismo tiempo en un solo navegador web en la Consola de administración de AWS. Para obtener más información, consulte [Cómo iniciar sesión en varias cuentas](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/multisession.html) en la *Guía de introducción a Consola de administración de AWS*.

1. En la página **Switch Role (Cambiar rol)**, escriba el número del ID de la cuenta o el alias de la cuenta y el nombre del rol que le proporcionó el administrador.
**nota**  
Si su administrador creó el rol con una ruta como, por ejemplo, `division_abc/subdivision_efg/roleToDoX`, deberá escribir dicha ruta y el nombre completos en el recuadro **Role (Rol)**. Si escribe solamente el nombre del rol, o si la longitud combinada de `Path` y `RoleName` sobrepasa los 64 caracteres, el cambio de rol producirá un error. Se trata de un límite de las cookies del navegador que almacenan el nombre del rol. Si esto ocurre, póngase en contacto con el administrador y pídale que reduzca el tamaño de la ruta y del nombre del rol.

1. (Opcional) Puede introducir un nombre para mostrar y elegir un color de visualización que resalte el rol en la barra de navegación de la consola.
   + En **Nombre de visualización**, escriba el texto que quiere que aparezca en la barra de navegación, en lugar de su nombre de usuario, cuando este rol esté activo. El sistema le sugiere un nombre en función de la información de la cuenta y del rol, pero puede cambiarlo si lo desea. 
   + En **Color de visualización**, elija un color para resaltar el nombre de visualización.

   El nombre y el color pueden ayudarle a saber cuándo está activo el rol, lo que modificará sus permisos. Por ejemplo, en el caso de un rol que le ofrece acceso al entorno de prueba, puede especificar un **Nombre que mostrar** de **Test** y seleccionar el **Color** verde. En el caso de un rol que le ofrece acceso al entorno de producción, puede especificar un **Nombre de visualización** de **Production** y seleccionar el **Color** rojo.

1. Elija **Switch Role**. El nombre y el color de visualización sustituyen su nombre de usuario en la barra de navegación y, a partir de ese momento, puede empezar a utilizar los permisos que le concede dicho rol.

1. Una vez que haya completado las tareas que requieren el rol de IAM, puede volver a su sesión original. De este modo, se eliminarán los permisos adicionales proporcionados por el rol y se devolverán los permisos estándar.

   1. En la consola de IAM, elija el **Nombre de visualización** del rol en la parte superior derecha de la barra de navegación.

   1. Elija **Volver**.

      Por ejemplo, supongamos que ha iniciado sesión en el número de cuenta `123456789012` con el nombre de usuario `Richard`. Después de utilizar el rol `admin-role`, desea dejar de utilizarlo y volver a los permisos originales. Para dejar de utilizar el rol, elija **admin-role @ 123456789012** y luego elija **Volver**.  
![\[Gráfico que muestra la función Volver para dejar de utilizar un rol de IAM y volver al usuario original.\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/role-stop-using.png)

**sugerencia**  
Los últimos roles que utilizó aparecen en el menú . La próxima vez que necesite cambiar a uno de estos roles, solo debe elegir el rol que prefiera. Si el rol no se muestra en el menú, solo tiene que escribir la información de la cuenta y del rol manualmente.

## Recursos adicionales
<a name="id_roles_use_switch-role-console_additional_resources"></a>
+ [Conceder a un usuario permisos para cambiar de rol](id_roles_use_permissions-to-switch.md)
+ [Conceder permisos a un usuario para transferir un rol a un servicio de AWS](id_roles_use_passrole.md)
+ [Creación de un rol para delegar permisos a un usuario de IAM](id_roles_create_for-user.md)
+ [Crear un rol para delegar permisos a un servicio de AWS](id_roles_create_for-service.md)
+ [Solucionar problemas de roles de IAM](troubleshoot_roles.md)

# Cambiar a un rol de IAM (AWS CLI)
<a name="id_roles_use_switch-role-cli"></a>

Un *rol* especifica un conjunto de permisos que puede utilizar para acceder a los recursos de AWS que necesita. En este sentido, es similar a un [usuario de IAM en AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html). Al iniciar sesión como usuario, obtendrá un conjunto específico de permisos. Sin embargo, no inicia sesión en una función, sino que después de iniciar sesión como usuario, puede cambiar a una función. Esto anula temporalmente los permisos de usuario originales y, en su lugar, le otorga los permisos asignados al rol. El rol puede estar en su propia cuenta o en cualquier otra Cuenta de AWS. Para obtener más información acerca de los roles, sus beneficios y cómo crearlos y configurarlos, consulte [Roles de IAM](id_roles.md) y [Creación de roles de IAM](id_roles_create.md). Para obtener más información sobre los distintos métodos que puede utilizar para asumir un rol, consulte [Métodos para asumir un rol](id_roles_manage-assume.md).

**importante**  
Los permisos del usuario de IAM y de cualquier rol que asuma no se acumulan. Solo hay un conjunto de permisos activo a la vez. Cuando se asume un rol, se abandonan temporalmente los permisos de usuario o del rol anteriores y se trabaja con los permisos que el rol tenga asignados. Al salir del rol, los permisos de usuario se restablecen de forma automática.

Puede utilizar un rol para ejecutar un comando de la AWS CLI si ha iniciado sesión como usuario de IAM. También puede utilizar un rol para ejecutar un comando AWS CLI de la cuando haya iniciado sesión como [usuario autenticado externamente](id_roles_providers.md) ([SAML](id_roles_providers_saml.md) o [OIDC](id_roles_providers_oidc.md)) que ya utiliza un rol. Además, puede utilizar un rol para ejecutar un comando de la AWS CLI desde una instancia de Amazon EC2 que esté asociada a un rol a través de su perfil de instancias. No puede asumir un rol si ha iniciado sesión como usuario Usuario raíz de la cuenta de AWS.

[**Encadenamiento de roles**](id_roles.md#iam-term-role-chaining)— También puede utilizar el encadenamiento de roles, que consiste en utilizar permisos de un rol para tener acceso a otro.

De forma predeterminada, la sesión de rol dura una hora. Cuando se asume este rol utilizando las operaciones de la CLI `assume-role*`, se puede especificar un valor para el parámetro `duration-seconds`. Este valor puede oscilar entre 900 segundos (15 minutos) y el valor de la duración máxima de la sesión para el rol. Si cambia de rol en la consola, la duración de la sesión se limita a un máximo de una hora. Para obtener información sobre cómo ver el valor máximo para el rol, consulte [Actualizar la duración máxima de la sesión para un rol](id_roles_update-role-settings.md#id_roles_update-session-duration). 

Si utiliza el encadenamiento de roles, la sesión tiene una duración máxima de una hora. Si utiliza a continuación el parámetro `duration-seconds` para proporcionar un valor superior a una hora, la operación generará un error.

## Escenario de ejemplo: cambio a un rol de producción
<a name="switch-role-cli-scenario-prod-env"></a>

Imagine que es un usuario de IAM para trabajar en el entorno de desarrollo. En esta situación, ocasionalmente necesita trabajar con el entorno de producción en la línea de comandos con la [AWS CLI](https://aws.amazon.com/cli/). Ya tiene una credencial de clave de acceso a su disposición. Este puede ser el par de claves de acceso asignado a su usuario de IAM estándar. O bien, si inició sesión como una entidad principal federada de SAML u OIDC, pueden ser el par de claves de acceso del rol que se le asignó inicialmente. Si sus permisos actuales le permiten asumir un rol IAM específico, puede identificar dicho rol en un "perfil" de los archivos de configuración de AWS CLI. Este comando se ejecuta con los permisos de la función de IAM especificada, no con la identidad original. Tenga en cuenta que al especificar dicho perfil en un comando de la AWS CLI, está utilizando el nuevo rol. En esta situación, no puede hacer uso de sus permisos originales en la cuenta de desarrollo al mismo tiempo. La razón es que no puede haber más de un conjunto de permisos en vigor a la vez.

**nota**  
Por motivos de seguridad, los administradores pueden [revisar los registros de AWS CloudTrail](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) para saber quién realizó una acción en AWS. Es posible que el administrador requiera que especifique una identidad de origen o un nombre de la sesión de rol cuando asuma el rol. Para obtener más información, consulte [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) y [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

**Para cambiar a una función de producción (AWS CLI)**

1. <a name="step-configure-default"></a>En caso de que nunca haya utilizado AWS CLI, primero debe configurar su perfil de CLI predeterminado. Abra un símbolo del sistema y configure la instalación de AWS CLI para utilizar la clave de acceso de su usuario de IAM o de su rol federado. Para obtener más información, consulte [Configuración de la AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-quick-configuration) en la *Guía del usuario de AWS Command Line Interface*.

   Ejecute el comando [aws configure](https://docs.aws.amazon.com/cli/latest/reference/configure/) de la siguiente manera:

   ```
   aws configure
   ```

   Cuando se le pida, proporcione la siguiente información:

   ```
   AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
   AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   Default region name [None]: us-east-2
   Default output format [None]: json
   ```

1. Cree un nuevo perfil para la función del archivo `.aws/config` en Unix o Linux, o el archivo `C:\Users\USERNAME\.aws\config` en Windows. El siguiente ejemplo crea un perfil denominado `prodaccess` que cambia a la función `ProductionAccessRole` en la cuenta `123456789012`. Obtendrá el ARN del rol del administrador de la cuenta que creó el rol. Si este perfil se invoca, AWS CLI utiliza las credenciales de `source_profile` para solicitar credenciales para el rol. Por esta razón, la identidad a la que se hace referencia como `source_profile` debe tener permisos de `sts:AssumeRole` para la función especificada en `role_arn`.

   ```
   [profile prodaccess]
       role_arn = arn:aws:iam::123456789012:role/ProductionAccessRole
       source_profile = default
   ```

1. Después de crear el nuevo perfil, cualquier comando de AWS CLI que especifique el parámetro `--profile prodaccess` se ejecuta bajo los permisos asociados al rol de IAM `ProductionAccessRole` en lugar de hacerlo en el usuario predeterminado.

   ```
   aws iam list-users --profile prodaccess
   ```

   Este comando funciona si los permisos asignados a `ProductionAccessRole` permiten enumerar los usuarios de la cuenta actual de AWS.

1. Para volver a los permisos concedidos por sus credenciales originales, ejecute comandos sin el parámetro `--profile`. La AWS CLI vuelve a utilizar las credenciales de su perfil predeterminado, que configuró en [Step 1](#step-configure-default).

Para obtener más información, consulte [Asumir un rol](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html) en la *Guía del usuario de AWS Command Line Interface*.

## Escenario de ejemplo: Permitir que una función de perfil de instancias cambie una función en otra cuenta
<a name="switch-role-cli-scenario-ec2-instance"></a>

Imagine que está utilizando dos Cuentas de AWS y desea permitir que una aplicación se ejecute en una instancia de Amazon EC2 para ejecutar comandos [AWS CLI](https://aws.amazon.com/cli/) en ambas cuentas. Supongamos que la instancia EC2 existe en la cuenta `111111111111`. Dicha instancia incluye la función de perfil de instancias `abcd` que permite que la aplicación realice tareas de solo lectura de Amazon S3 en el bucket `amzn-s3-demo-bucket1` dentro de la misma cuenta `111111111111`. Sin embargo, la aplicación también debe tener permitido asumir la función entre cuentas `efgh` para realizar tareas de la cuenta `222222222222`. Para ello, la función del perfil de instancia EC2 `abcd` debe tener la siguiente política de permisos:

***Política de permisos del rol de la cuenta 111111111111 `abcd`***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket1/*",
                "arn:aws:s3:::amzn-s3-demo-bucket1"
            ]
        },
        {
            "Sid": "AllowIPToAssumeCrossAccountRole",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::222222222222:role/efgh"
        }
    ]
}
```

------

Supongamos que la función entre cuentas `efgh` permite tareas de solo lectura de Amazon S3 en el bucket `amzn-s3-demo-bucket2` dentro de la misma cuenta `222222222222`. Para ello, la función entre cuentas `efgh` debe tener la siguiente política de permisos:

***Política de permisos del rol de la cuenta 222222222222 `efgh`***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket2/*",
                "arn:aws:s3:::amzn-s3-demo-bucket2"
            ]
        }
    ]
}
```

------

La función `efgh` debe permitir la función de perfil de instancia `abcd` para asumirla. Para ello, la función `efgh` debe tener la siguiente política de confianza:

***Política de confianza de rol `efgh` de la cuenta 222222222222 ***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "efghTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"}
        }
    ]
}
```

------

Para ejecutar los comandos de la AWS CLI en la cuenta `222222222222`, debe actualizar el archivo de configuración de la CLI. Identifique la función `efgh` como el "perfil" y la función del perfil de instancia EC2 `abcd` como la "fuente de credenciales" en el archivo de configuración de la AWS CLI. A continuación, los comandos de la CLI se ejecutan con los permisos de la función `efgh`, no la función `abcd` original.

**nota**  
Por motivos de seguridad, puede utilizar AWS CloudTrail para auditar el uso de roles en la cuenta. Para diferenciar entre sesiones de rol cuando diferentes entidades principales utilizan un rol en los logs de CloudTrail, puede utilizar el nombre de sesión de rol. Si la AWS CLI asume un rol en nombre de un usuario, tal y como se describe en este tema, se crea automáticamente un nombre de sesión de rol con el formato `AWS-CLI-session-nnnnnnnn`. Aquí *nnnnnnnn* es un número entero que representa la hora en [formato de tiempo Unix](http://wikipedia.org/wiki/Unix_time) (el número de segundos desde la medianoche UTC del 1 de enero de 1970). Para obtener más información, consulte [Referencia de eventos de CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/eventreference.html) en la *Guía del usuario de AWS CloudTrail*.

**Para permitir que un perfil de instancia de EC2 cambie a una función entre cuentas (AWS CLI)**

1. No tiene que configurar un perfil de CLI predeterminado. En su lugar, puede cargar las credenciales de los metadatos del perfil de instancia EC2. Cree un nuevo perfil para el rol en el archivo `.aws/config`. En el siguiente ejemplo, se crea un perfil `instancecrossaccount` que cambia a la función `efgh` en la cuenta `222222222222`. Si este perfil se invoca, la AWS CLI utiliza las credenciales de los metadatos del perfil de instancia EC2 para solicitar credenciales para la función. Por esta razón, la función del perfil de instancia EC2 debe tener permisos de `sts:AssumeRole` para la función especificada en `role_arn`.

   ```
   [profile instancecrossaccount]
   role_arn = arn:aws:iam::222222222222:role/efgh
   credential_source = Ec2InstanceMetadata
   ```

1. Después de crear el nuevo perfil, cualquier comando de AWS CLI que especifique el parámetro `--profile instancecrossaccount` se ejecuta bajo los permisos asociados a la función de `efgh` en la cuenta `222222222222`.

   ```
   aws s3 ls amzn-s3-demo-bucket2 --profile instancecrossaccount
   ```

   Este comando funciona si los permisos asignados a la función `efgh` permiten enumerar los usuarios de la Cuenta de AWS actual.

1. Para volver a los permisos del perfil de instancia EC2 original de la cuenta `111111111111`, ejecute los comandos de la CLI sin el parámetro `--profile`.

Para obtener más información, consulte [Asumir un rol](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html) en la *Guía del usuario de AWS Command Line Interface*.

# Cambiar a un rol de IAM (Herramientas para Windows PowerShell)
<a name="id_roles_use_switch-role-twp"></a>

Un *rol* especifica un conjunto de permisos que puede utilizar para acceder a los recursos de AWS que necesita. En este sentido, es similar a un [usuario de IAM en AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html). Al iniciar sesión como usuario, obtendrá un conjunto específico de permisos. Sin embargo, no inicia sesión en un rol propiamente, si no que al iniciar sesión puede cambiar a un rol. Esto anula temporalmente los permisos de usuario originales y, en su lugar, le otorga los permisos asignados al rol. El rol puede estar en su propia cuenta o en cualquier otra Cuenta de AWS. Para obtener más información acerca de los roles, sus beneficios y cómo crearlos y configurarlos, consulte [Roles de IAM](id_roles.md) y [Creación de roles de IAM](id_roles_create.md).

**importante**  
Los permisos de sus usuarios de IAM y de cualquier rol al que cambie no se acumulan. Solo hay un conjunto de permisos activo a la vez. Cuando se cambia a un rol, se abandonan temporalmente los permisos de usuario y se trabaja con los permisos que el rol tenga asignados. Al salir del rol, los permisos de usuario se restablecen de forma automática.

En esta sección se describe cómo cambiar de rol cuando trabaja en la línea de comando con la AWS Tools for Windows PowerShell.

Supongamos que dispone de una cuenta para trabajar en el entorno de desarrollo y que de vez en cuando tiene que trabajar en el entorno de producción en la línea de comandos con [Tools for Windows PowerShell](https://aws.amazon.com/powershell/). Ya tiene una credencial de clave de acceso a su disposición. Puede ser un par de claves de acceso asignado a su usuario de IAM estándar. O bien, si inició sesión como una entidad principal federada de SAML u OIDC, dichas credenciales pueden corresponder al par de claves de acceso del rol que se le asignó inicialmente. Puede utilizar estas credenciales para ejecutar el cmdlet `Use-STSRole` que transfiere el ARN de un rol nuevo como parámetro. El comando devuelve credenciales de seguridad temporales para el rol solicitado. Puede utilizar estas credenciales en comandos de PowerShell posteriores con los permisos del rol para obtener acceso a los recursos de producción. Mientras utiliza el rol, no puede utilizar sus permisos de usuario de la cuenta Development ya que solo puede haber un conjunto de permisos en vigor a la vez.

**nota**  
Por motivos de seguridad, los administradores pueden [revisar los registros de AWS CloudTrail](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) para saber quién realizó una acción en AWS. Es posible que el administrador requiera que especifique una identidad de origen o un nombre de la sesión de rol cuando asuma el rol. Para obtener más información, consulte [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) y [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

Tenga en cuenta que todas las claves de acceso y tokens solo son ejemplos y no se pueden utilizar tal y como se muestran. Tiene que sustituirlos por los valores adecuados de su entorno real.

**Para cambiar a un rol (Tools for Windows PowerShell)**

1. Abra un símbolo del sistema de PowerShell y configure el perfil predeterminado para utilizar la clave de acceso de su usuario de IAM actual o de su rol federado. Si ya ha utilizado anteriormente Tools for Windows PowerShell, probablemente esta tarea ya esté completada. Tenga en cuenta que solo puede cambiar de rol si inicia sesión como un usuario de IAM y no como el Usuario raíz de la cuenta de AWS.

   ```
   PS C:\> Set-AWSCredentials -AccessKey AKIAIOSFODNN7EXAMPLE -SecretKey wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY -StoreAs MyMainUserProfile
   PS C:\> Initialize-AWSDefaults -ProfileName MyMainUserProfile -Region us-east-2
   ```

   Para obtener más información, consulte la [especificación de credenciales AWS](https://docs.aws.amazon.com/powershell/latest/userguide/specifying-your-aws-credentials.html) en la *Guía del usuario de Herramientas de AWS para PowerShell*.

1. Para recuperar credenciales para el nuevo rol, ejecute el siguiente comando para cambiar al rol `RoleName` de la cuenta 123456789012. Obtendrá el ARN del rol del administrador de la cuenta que creó el rol. El comando requiere que indique también un nombre de sesión. Puede elegir cualquier texto para ello. El comando siguiente solicita las credenciales y después captura el objeto de propiedad `Credentials` del objeto de los resultados devueltos y lo almacena en la variable `$Creds`.

   ```
   PS C:\> $Creds = (Use-STSRole -RoleArn "arn:aws:iam::123456789012:role/RoleName" -RoleSessionName "MyRoleSessionName").Credentials
   ```

   `$Creds` es un objeto que ahora contiene los elementos `AccessKeyId`, `SecretAccessKey` y `SessionToken` que necesita en los pasos siguientes. Los siguientes comandos de ejemplo ilustran valores típicos:

   ```
   PS C:\> $Creds.AccessKeyId
   AKIAIOSFODNN7EXAMPLE
   
   PS C:\> $Creds.SecretAccessKey
   wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   
   PS C:\> $Creds.SessionToken
   AQoDYXdzEGcaEXAMPLE2gsYULo+Im5ZEXAMPLEeYjs1M2FUIgIJx9tQqNMBEXAMPLECvSRyh0FW7jEXAMPLEW+vE/7s1HRp
   XviG7b+qYf4nD00EXAMPLEmj4wxS04L/uZEXAMPLECihzFB5lTYLto9dyBgSDyEXAMPLE9/g7QRUhZp4bqbEXAMPLENwGPy
   Oj59pFA4lNKCIkVgkREXAMPLEjlzxQ7y52gekeVEXAMPLEDiB9ST3UuysgsKdEXAMPLE1TVastU1A0SKFEXAMPLEiywCC/C
   s8EXAMPLEpZgOs+6hz4AP4KEXAMPLERbASP+4eZScEXAMPLEsnf87eNhyDHq6ikBQ==
   
   PS C:\> $Creds.Expiration
   Thursday, June 18, 2018 2:28:31 PM
   ```

1. Para utilizar estas credenciales para cualquier comando posterior, inclúyalas en el parámetro `-Credential`. Por ejemplo, el comando siguiente utiliza las credenciales del rol y trabaja únicamente si se concede al rol el permiso `iam:ListRoles` y, por lo tanto, puede ejecutar el cmdlet `Get-IAMRoles`:

   ```
           PS C:\> get-iamroles -Credential $Creds
   ```

1. Para volver a tener sus credenciales originales, solo tiene que dejar de utilizar el parámetro `-Credentials $Creds` y permitir que PowerShell revierta a las credenciales que están almacenadas en el perfil predeterminado.

# Cambiar a un rol de IAM (API de AWS)
<a name="id_roles_use_switch-role-api"></a>

Un *rol* especifica un conjunto de permisos que puede utilizar para el acceso a los recursos de AWS. En este sentido, es similar a un [usuario de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html). Una entidad principal (persona o aplicación) asume un rol para recibir permisos temporales con los que realizar las tareas necesarias e interactuar con los recursos de AWS. El rol puede estar en su propia cuenta o en cualquier otra Cuenta de AWS. Para obtener más información acerca de los roles, sus beneficios y cómo crearlos y configurarlos, consulte [Roles de IAM](id_roles.md) y [Creación de roles de IAM](id_roles_create.md). Para obtener más información sobre los distintos métodos que puede utilizar para asumir un rol, consulte [Métodos para asumir un rol](id_roles_manage-assume.md).

**importante**  
Los permisos del usuario de IAM y de cualquier rol que asuma no se acumulan. Solo hay un conjunto de permisos activo a la vez. Cuando se asume un rol, se abandonan temporalmente los permisos de usuario o del rol anteriores y se trabaja con los permisos que el rol tenga asignados. Al salir del rol, los permisos originales se restablecen de forma automática.

Para asumir un rol, una aplicación llama a la operación de la API de AWS STS [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) y transfiere el ARN del rol que se utilizará. La operación crea una nueva sesión con credenciales temporales. Esta sesión tiene los mismos permisos que las políticas basadas en identidad aplicables al rol. 

Cuando se llama a [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html), también se puede pasar opcionalmente una [política de sesión](access_policies.md#policies_session) gestionada o insertada. Las políticas de sesión son políticas avanzadas que se transfieren como parámetro al crear mediante programación una sesión de credenciales temporales para un rol o una sesión de usuario federado. Puede transferir un único documento de política de sesión insertada JSON utilizando el parámetro `Policy`. Puede utilizar el parámetro `PolicyArns` para especificar hasta 10 políticas de sesión administrada. Los permisos de la sesión resultantes son la intersección de las políticas basadas en identidades de la entidad y las políticas de la sesión. Las políticas de sesión son útiles cuando es necesario proporcionar las credenciales temporales del rol a otra persona. Pueden utilizar las credenciales temporales del rol en las llamadas posteriores a la API de AWS para tener acceso a los recursos de la cuenta propietaria del rol. Las políticas de sesión no se pueden utilizar para conceder más permisos que los permitidos por la política basada en identidades. Para obtener más información sobre cómo determina AWS los permisos efectivos de un rol, consulte [Lógica de evaluación de políticas](reference_policies_evaluation-logic.md). 

![\[PermissionsWhenPassingRoles_Diagram\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/role_passed_policy_permissions.png)


Puede llamar a `AssumeRole` cuando haya iniciado sesión como usuario de IAM, o como usuario [autenticado externamente](id_roles_providers.md) ([SAML](id_roles_providers_saml.md) o [OIDC](id_roles_providers_oidc.md)) que ya utiliza un rol. También puede utilizar el [*encadenamiento de roles*](id_roles.md#iam-term-role-chaining), que consiste en utilizar un rol para asumir otro. No puede asumir un rol si ha iniciado sesión como usuario Usuario raíz de la cuenta de AWS.

De forma predeterminada, la sesión de rol dura una hora. Cuando se asume este rol utilizando las operaciones de la API de AWS STS [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html), se puede especificar un valor para el parámetro `DurationSeconds`. Este valor puede oscilar entre 900 segundos (15 minutos) y el valor de la duración máxima de la sesión para el rol. Para obtener información sobre cómo ver el valor máximo para el rol, consulte [Actualizar la duración máxima de la sesión para un rol](id_roles_update-role-settings.md#id_roles_update-session-duration). 

Si utiliza el encadenamiento de roles, la sesión tiene una duración máxima de una hora. Si utiliza a continuación el parámetro `DurationSeconds` para proporcionar un valor superior a una hora, la operación generará un error.

**nota**  
Por motivos de seguridad, los administradores pueden [revisar los registros de AWS CloudTrail](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds) para saber quién realizó una acción en AWS. Es posible que el administrador requiera que especifique una identidad de origen o un nombre de la sesión de rol cuando asuma el rol. Para obtener más información, consulte [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) y [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

Los siguientes ejemplos de código muestran cómo crear un usuario y asumir un rol.

**aviso**  
Para evitar riesgos de seguridad, no utilice a los usuarios de IAM para la autenticación cuando desarrolle software especialmente diseñado o trabaje con datos reales. En cambio, utilice la federación con un proveedor de identidades como [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
+ Crear un usuario que no tenga permisos.
+ Crear un rol que conceda permiso para enumerar los buckets de Amazon S3 para la cuenta.
+ Agregar una política para que el usuario asuma el rol.
+ Asumir el rol y enumerar los buckets de S3 con credenciales temporales, y después limpiar los recursos.

------
#### [ .NET ]

**SDK para .NET**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/IAM#code-examples). 

```
global using Amazon.IdentityManagement;
global using Amazon.S3;
global using Amazon.SecurityToken;
global using IAMActions;
global using IamScenariosCommon;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Logging;
global using Microsoft.Extensions.Logging.Console;
global using Microsoft.Extensions.Logging.Debug;


namespace IAMActions;

public class IAMWrapper
{
    private readonly IAmazonIdentityManagementService _IAMService;

    /// <summary>
    /// Constructor for the IAMWrapper class.
    /// </summary>
    /// <param name="IAMService">An IAM client object.</param>
    public IAMWrapper(IAmazonIdentityManagementService IAMService)
    {
        _IAMService = IAMService;
    }

    /// <summary>
    /// Attach an IAM policy to a role.
    /// </summary>
    /// <param name="policyArn">The policy to attach.</param>
    /// <param name="roleName">The role that the policy will be attached to.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> AttachRolePolicyAsync(string policyArn, string roleName)
    {
        var response = await _IAMService.AttachRolePolicyAsync(new AttachRolePolicyRequest
        {
            PolicyArn = policyArn,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Create an IAM access key for a user.
    /// </summary>
    /// <param name="userName">The username for which to create the IAM access
    /// key.</param>
    /// <returns>The AccessKey.</returns>
    public async Task<AccessKey> CreateAccessKeyAsync(string userName)
    {
        var response = await _IAMService.CreateAccessKeyAsync(new CreateAccessKeyRequest
        {
            UserName = userName,
        });

        return response.AccessKey;

    }


    /// <summary>
    /// Create an IAM policy.
    /// </summary>
    /// <param name="policyName">The name to give the new IAM policy.</param>
    /// <param name="policyDocument">The policy document for the new policy.</param>
    /// <returns>The new IAM policy object.</returns>
    public async Task<ManagedPolicy> CreatePolicyAsync(string policyName, string policyDocument)
    {
        var response = await _IAMService.CreatePolicyAsync(new CreatePolicyRequest
        {
            PolicyDocument = policyDocument,
            PolicyName = policyName,
        });

        return response.Policy;
    }


    /// <summary>
    /// Create a new IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="rolePolicyDocument">The name of the IAM policy document
    /// for the new role.</param>
    /// <returns>The Amazon Resource Name (ARN) of the role.</returns>
    public async Task<string> CreateRoleAsync(string roleName, string rolePolicyDocument)
    {
        var request = new CreateRoleRequest
        {
            RoleName = roleName,
            AssumeRolePolicyDocument = rolePolicyDocument,
        };

        var response = await _IAMService.CreateRoleAsync(request);
        return response.Role.Arn;
    }


    /// <summary>
    /// Create an IAM service-linked role.
    /// </summary>
    /// <param name="serviceName">The name of the AWS Service.</param>
    /// <param name="description">A description of the IAM service-linked role.</param>
    /// <returns>The IAM role that was created.</returns>
    public async Task<Role> CreateServiceLinkedRoleAsync(string serviceName, string description)
    {
        var request = new CreateServiceLinkedRoleRequest
        {
            AWSServiceName = serviceName,
            Description = description
        };

        var response = await _IAMService.CreateServiceLinkedRoleAsync(request);
        return response.Role;
    }


    /// <summary>
    /// Create an IAM user.
    /// </summary>
    /// <param name="userName">The username for the new IAM user.</param>
    /// <returns>The IAM user that was created.</returns>
    public async Task<User> CreateUserAsync(string userName)
    {
        var response = await _IAMService.CreateUserAsync(new CreateUserRequest { UserName = userName });
        return response.User;
    }


    /// <summary>
    /// Delete an IAM user's access key.
    /// </summary>
    /// <param name="accessKeyId">The Id for the IAM access key.</param>
    /// <param name="userName">The username of the user that owns the IAM
    /// access key.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteAccessKeyAsync(string accessKeyId, string userName)
    {
        var response = await _IAMService.DeleteAccessKeyAsync(new DeleteAccessKeyRequest
        {
            AccessKeyId = accessKeyId,
            UserName = userName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM policy.
    /// </summary>
    /// <param name="policyArn">The Amazon Resource Name (ARN) of the policy to
    /// delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeletePolicyAsync(string policyArn)
    {
        var response = await _IAMService.DeletePolicyAsync(new DeletePolicyRequest { PolicyArn = policyArn });
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteRoleAsync(string roleName)
    {
        var response = await _IAMService.DeleteRoleAsync(new DeleteRoleRequest { RoleName = roleName });
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM role policy.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="policyName">The name of the IAM role policy to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteRolePolicyAsync(string roleName, string policyName)
    {
        var response = await _IAMService.DeleteRolePolicyAsync(new DeleteRolePolicyRequest
        {
            PolicyName = policyName,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM user.
    /// </summary>
    /// <param name="userName">The username of the IAM user to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteUserAsync(string userName)
    {
        var response = await _IAMService.DeleteUserAsync(new DeleteUserRequest { UserName = userName });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM user policy.
    /// </summary>
    /// <param name="policyName">The name of the IAM policy to delete.</param>
    /// <param name="userName">The username of the IAM user.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteUserPolicyAsync(string policyName, string userName)
    {
        var response = await _IAMService.DeleteUserPolicyAsync(new DeleteUserPolicyRequest { PolicyName = policyName, UserName = userName });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Detach an IAM policy from an IAM role.
    /// </summary>
    /// <param name="policyArn">The Amazon Resource Name (ARN) of the IAM policy.</param>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DetachRolePolicyAsync(string policyArn, string roleName)
    {
        var response = await _IAMService.DetachRolePolicyAsync(new DetachRolePolicyRequest
        {
            PolicyArn = policyArn,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Gets the IAM password policy for an AWS account.
    /// </summary>
    /// <returns>The PasswordPolicy for the AWS account.</returns>
    public async Task<PasswordPolicy> GetAccountPasswordPolicyAsync()
    {
        var response = await _IAMService.GetAccountPasswordPolicyAsync(new GetAccountPasswordPolicyRequest());
        return response.PasswordPolicy;
    }


    /// <summary>
    /// Get information about an IAM policy.
    /// </summary>
    /// <param name="policyArn">The IAM policy to retrieve information for.</param>
    /// <returns>The IAM policy.</returns>
    public async Task<ManagedPolicy> GetPolicyAsync(string policyArn)
    {

        var response = await _IAMService.GetPolicyAsync(new GetPolicyRequest { PolicyArn = policyArn });
        return response.Policy;
    }


    /// <summary>
    /// Get information about an IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role to retrieve information
    /// for.</param>
    /// <returns>The IAM role that was retrieved.</returns>
    public async Task<Role> GetRoleAsync(string roleName)
    {
        var response = await _IAMService.GetRoleAsync(new GetRoleRequest
        {
            RoleName = roleName,
        });

        return response.Role;
    }


    /// <summary>
    /// Get information about an IAM user.
    /// </summary>
    /// <param name="userName">The username of the user.</param>
    /// <returns>An IAM user object.</returns>
    public async Task<User> GetUserAsync(string userName)
    {
        var response = await _IAMService.GetUserAsync(new GetUserRequest { UserName = userName });
        return response.User;
    }


    /// <summary>
    /// List the IAM role policies that are attached to an IAM role.
    /// </summary>
    /// <param name="roleName">The IAM role to list IAM policies for.</param>
    /// <returns>A list of the IAM policies attached to the IAM role.</returns>
    public async Task<List<AttachedPolicyType>> ListAttachedRolePoliciesAsync(string roleName)
    {
        var attachedPolicies = new List<AttachedPolicyType>();
        var attachedRolePoliciesPaginator = _IAMService.Paginators.ListAttachedRolePolicies(new ListAttachedRolePoliciesRequest { RoleName = roleName });

        await foreach (var response in attachedRolePoliciesPaginator.Responses)
        {
            attachedPolicies.AddRange(response.AttachedPolicies);
        }

        return attachedPolicies;
    }


    /// <summary>
    /// List IAM groups.
    /// </summary>
    /// <returns>A list of IAM groups.</returns>
    public async Task<List<Group>> ListGroupsAsync()
    {
        var groupsPaginator = _IAMService.Paginators.ListGroups(new ListGroupsRequest());
        var groups = new List<Group>();

        await foreach (var response in groupsPaginator.Responses)
        {
            groups.AddRange(response.Groups);
        }

        return groups;
    }


    /// <summary>
    /// List IAM policies.
    /// </summary>
    /// <returns>A list of the IAM policies.</returns>
    public async Task<List<ManagedPolicy>> ListPoliciesAsync()
    {
        var listPoliciesPaginator = _IAMService.Paginators.ListPolicies(new ListPoliciesRequest());
        var policies = new List<ManagedPolicy>();

        await foreach (var response in listPoliciesPaginator.Responses)
        {
            policies.AddRange(response.Policies);
        }

        return policies;
    }


    /// <summary>
    /// List IAM role policies.
    /// </summary>
    /// <param name="roleName">The IAM role for which to list IAM policies.</param>
    /// <returns>A list of IAM policy names.</returns>
    public async Task<List<string>> ListRolePoliciesAsync(string roleName)
    {
        var listRolePoliciesPaginator = _IAMService.Paginators.ListRolePolicies(new ListRolePoliciesRequest { RoleName = roleName });
        var policyNames = new List<string>();

        await foreach (var response in listRolePoliciesPaginator.Responses)
        {
            policyNames.AddRange(response.PolicyNames);
        }

        return policyNames;
    }


    /// <summary>
    /// List IAM roles.
    /// </summary>
    /// <returns>A list of IAM roles.</returns>
    public async Task<List<Role>> ListRolesAsync()
    {
        var listRolesPaginator = _IAMService.Paginators.ListRoles(new ListRolesRequest());
        var roles = new List<Role>();

        await foreach (var response in listRolesPaginator.Responses)
        {
            roles.AddRange(response.Roles);
        }

        return roles;
    }


    /// <summary>
    /// List SAML authentication providers.
    /// </summary>
    /// <returns>A list of SAML providers.</returns>
    public async Task<List<SAMLProviderListEntry>> ListSAMLProvidersAsync()
    {
        var response = await _IAMService.ListSAMLProvidersAsync(new ListSAMLProvidersRequest());
        return response.SAMLProviderList;
    }


    /// <summary>
    /// List IAM users.
    /// </summary>
    /// <returns>A list of IAM users.</returns>
    public async Task<List<User>> ListUsersAsync()
    {
        var listUsersPaginator = _IAMService.Paginators.ListUsers(new ListUsersRequest());
        var users = new List<User>();

        await foreach (var response in listUsersPaginator.Responses)
        {
            users.AddRange(response.Users);
        }

        return users;
    }


    /// <summary>
    /// Update the inline policy document embedded in a role.
    /// </summary>
    /// <param name="policyName">The name of the policy to embed.</param>
    /// <param name="roleName">The name of the role to update.</param>
    /// <param name="policyDocument">The policy document that defines the role.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> PutRolePolicyAsync(string policyName, string roleName, string policyDocument)
    {
        var request = new PutRolePolicyRequest
        {
            PolicyName = policyName,
            RoleName = roleName,
            PolicyDocument = policyDocument
        };

        var response = await _IAMService.PutRolePolicyAsync(request);
        return response.HttpStatusCode == HttpStatusCode.OK;
    }


    /// <summary>
    /// Add or update an inline policy document that is embedded in an IAM user.
    /// </summary>
    /// <param name="userName">The name of the IAM user.</param>
    /// <param name="policyName">The name of the IAM policy.</param>
    /// <param name="policyDocument">The policy document defining the IAM policy.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> PutUserPolicyAsync(string userName, string policyName, string policyDocument)
    {
        var request = new PutUserPolicyRequest
        {
            UserName = userName,
            PolicyName = policyName,
            PolicyDocument = policyDocument
        };

        var response = await _IAMService.PutUserPolicyAsync(request);
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }

    /// <summary>
    /// Wait for a new access key to be ready to use.
    /// </summary>
    /// <param name="accessKeyId">The Id of the access key.</param>
    /// <returns>A boolean value indicating the success of the action.</returns>
    public async Task<bool> WaitUntilAccessKeyIsReady(string accessKeyId)
    {
        var keyReady = false;

        do
        {
            try
            {
                var response = await _IAMService.GetAccessKeyLastUsedAsync(
                    new GetAccessKeyLastUsedRequest { AccessKeyId = accessKeyId });
                if (response.UserName is not null)
                {
                    keyReady = true;
                }
            }
            catch (NoSuchEntityException)
            {
                keyReady = false;
            }
        } while (!keyReady);

        return keyReady;
    }
}



using Microsoft.Extensions.Configuration;

namespace IAMBasics;

public class IAMBasics
{
    private static ILogger logger = null!;

    static async Task Main(string[] args)
    {
        // Set up dependency injection for the AWS service.
        using var host = Host.CreateDefaultBuilder(args)
            .ConfigureLogging(logging =>
                logging.AddFilter("System", LogLevel.Debug)
                    .AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Information)
                    .AddFilter<ConsoleLoggerProvider>("Microsoft", LogLevel.Trace))
            .ConfigureServices((_, services) =>
            services.AddAWSService<IAmazonIdentityManagementService>()
            .AddTransient<IAMWrapper>()
            .AddTransient<UIWrapper>()
            )
            .Build();

        logger = LoggerFactory.Create(builder => { builder.AddConsole(); })
            .CreateLogger<IAMBasics>();


        IConfiguration configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("settings.json") // Load test settings from .json file.
            .AddJsonFile("settings.local.json",
                true) // Optionally load local settings.
            .Build();

        // Values needed for user, role, and policies.
        string userName = configuration["UserName"]!;
        string s3PolicyName = configuration["S3PolicyName"]!;
        string roleName = configuration["RoleName"]!;


        var iamWrapper = host.Services.GetRequiredService<IAMWrapper>();
        var uiWrapper = host.Services.GetRequiredService<UIWrapper>();

        uiWrapper.DisplayBasicsOverview();
        uiWrapper.PressEnter();

        // First create a user. By default, the new user has
        // no permissions.
        uiWrapper.DisplayTitle("Create User");
        Console.WriteLine($"Creating a new user with user name: {userName}.");
        var user = await iamWrapper.CreateUserAsync(userName);
        var userArn = user.Arn;

        Console.WriteLine($"Successfully created user: {userName} with ARN: {userArn}.");
        uiWrapper.WaitABit(15, "Now let's wait for the user to be ready for use.");

        // Define a role policy document that allows the new user
        // to assume the role.
        string assumeRolePolicyDocument = "{" +
          "\"Version\": \"2012-10-17\"," +
          "\"Statement\": [{" +
              "\"Effect\": \"Allow\"," +
              "\"Principal\": {" +
              $"	\"AWS\": \"{userArn}\"" +
              "}," +
              "\"Action\": \"sts:AssumeRole\"" +
          "}]" +
        "}";

        // Permissions to list all buckets.
        string policyDocument = "{" +
            "\"Version\": \"2012-10-17\"," +
            "	\"Statement\" : [{" +
                "	\"Action\" : [\"s3:ListAllMyBuckets\"]," +
                "	\"Effect\" : \"Allow\"," +
                "	\"Resource\" : \"*\"" +
            "}]" +
        "}";

        // Create an AccessKey for the user.
        uiWrapper.DisplayTitle("Create access key");
        Console.WriteLine("Now let's create an access key for the new user.");
        var accessKey = await iamWrapper.CreateAccessKeyAsync(userName);

        var accessKeyId = accessKey.AccessKeyId;
        var secretAccessKey = accessKey.SecretAccessKey;

        Console.WriteLine($"We have created the access key with Access key id: {accessKeyId}.");

        Console.WriteLine("Now let's wait until the IAM access key is ready to use.");
        var keyReady = await iamWrapper.WaitUntilAccessKeyIsReady(accessKeyId);

        // Now try listing the Amazon Simple Storage Service (Amazon S3)
        // buckets. This should fail at this point because the user doesn't
        // have permissions to perform this task.
        uiWrapper.DisplayTitle("Try to display Amazon S3 buckets");
        Console.WriteLine("Now let's try to display a list of the user's Amazon S3 buckets.");
        var s3Client1 = new AmazonS3Client(accessKeyId, secretAccessKey);
        var stsClient1 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey);

        var s3Wrapper = new S3Wrapper(s3Client1, stsClient1);
        var buckets = await s3Wrapper.ListMyBucketsAsync();

        Console.WriteLine(buckets is null
            ? "As expected, the call to list the buckets has returned a null list."
            : "Something went wrong. This shouldn't have worked.");

        uiWrapper.PressEnter();

        uiWrapper.DisplayTitle("Create IAM role");
        Console.WriteLine($"Creating the role: {roleName}");

        // Creating an IAM role to allow listing the S3 buckets. A role name
        // is not case sensitive and must be unique to the account for which it
        // is created.
        var roleArn = await iamWrapper.CreateRoleAsync(roleName, assumeRolePolicyDocument);

        uiWrapper.PressEnter();

        // Create a policy with permissions to list S3 buckets.
        uiWrapper.DisplayTitle("Create IAM policy");
        Console.WriteLine($"Creating the policy: {s3PolicyName}");
        Console.WriteLine("with permissions to list the Amazon S3 buckets for the account.");
        var policy = await iamWrapper.CreatePolicyAsync(s3PolicyName, policyDocument);

        // Wait 15 seconds for the IAM policy to be available.
        uiWrapper.WaitABit(15, "Waiting for the policy to be available.");

        // Attach the policy to the role you created earlier.
        uiWrapper.DisplayTitle("Attach new IAM policy");
        Console.WriteLine("Now let's attach the policy to the role.");
        await iamWrapper.AttachRolePolicyAsync(policy.Arn, roleName);

        // Wait 15 seconds for the role to be updated.
        Console.WriteLine();
        uiWrapper.WaitABit(15, "Waiting for the policy to be attached.");

        // Use the AWS Security Token Service (AWS STS) to have the user
        // assume the role we created.
        var stsClient2 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey);

        // Wait for the new credentials to become valid.
        uiWrapper.WaitABit(10, "Waiting for the credentials to be valid.");

        var assumedRoleCredentials = await s3Wrapper.AssumeS3RoleAsync("temporary-session", roleArn);

        // Try again to list the buckets using the client created with
        // the new user's credentials. This time, it should work.
        var s3Client2 = new AmazonS3Client(assumedRoleCredentials);

        s3Wrapper.UpdateClients(s3Client2, stsClient2);

        buckets = await s3Wrapper.ListMyBucketsAsync();

        uiWrapper.DisplayTitle("List Amazon S3 buckets");
        Console.WriteLine("This time we should have buckets to list.");
        if (buckets is not null)
        {
            buckets.ForEach(bucket =>
            {
                Console.WriteLine($"{bucket.BucketName} created: {bucket.CreationDate}");
            });
        }

        uiWrapper.PressEnter();

        // Now clean up all the resources used in the example.
        uiWrapper.DisplayTitle("Clean up resources");
        Console.WriteLine("Thank you for watching. The IAM Basics demo is complete.");
        Console.WriteLine("Please wait while we clean up the resources we created.");

        await iamWrapper.DetachRolePolicyAsync(policy.Arn, roleName);

        await iamWrapper.DeletePolicyAsync(policy.Arn);

        await iamWrapper.DeleteRoleAsync(roleName);

        await iamWrapper.DeleteAccessKeyAsync(accessKeyId, userName);

        await iamWrapper.DeleteUserAsync(userName);

        uiWrapper.PressEnter();

        Console.WriteLine("All done cleaning up our resources. Thank you for your patience.");
    }
}


namespace IamScenariosCommon;

using System.Net;

/// <summary>
/// A class to perform Amazon Simple Storage Service (Amazon S3) actions for
/// the IAM Basics scenario.
/// </summary>
public class S3Wrapper
{
    private IAmazonS3 _s3Service;
    private IAmazonSecurityTokenService _stsService;

    /// <summary>
    /// Constructor for the S3Wrapper class.
    /// </summary>
    /// <param name="s3Service">An Amazon S3 client object.</param>
    /// <param name="stsService">An AWS Security Token Service (AWS STS)
    /// client object.</param>
    public S3Wrapper(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService)
    {
        _s3Service = s3Service;
        _stsService = stsService;
    }

    /// <summary>
    /// Assumes an AWS Identity and Access Management (IAM) role that allows
    /// Amazon S3 access for the current session.
    /// </summary>
    /// <param name="roleSession">A string representing the current session.</param>
    /// <param name="roleToAssume">The name of the IAM role to assume.</param>
    /// <returns>Credentials for the newly assumed IAM role.</returns>
    public async Task<Credentials> AssumeS3RoleAsync(string roleSession, string roleToAssume)
    {
        // Create the request to use with the AssumeRoleAsync call.
        var request = new AssumeRoleRequest()
        {
            RoleSessionName = roleSession,
            RoleArn = roleToAssume,
        };

        var response = await _stsService.AssumeRoleAsync(request);

        return response.Credentials;
    }


    /// <summary>
    /// Delete an S3 bucket.
    /// </summary>
    /// <param name="bucketName">Name of the S3 bucket to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteBucketAsync(string bucketName)
    {
        var result = await _s3Service.DeleteBucketAsync(new DeleteBucketRequest { BucketName = bucketName });
        return result.HttpStatusCode == HttpStatusCode.OK;
    }

    /// <summary>
    /// List the buckets that are owned by the user's account.
    /// </summary>
    /// <returns>Async Task.</returns>
    public async Task<List<S3Bucket>?> ListMyBucketsAsync()
    {
        try
        {
            // Get the list of buckets accessible by the new user.
            var response = await _s3Service.ListBucketsAsync();

            return response.Buckets;
        }
        catch (AmazonS3Exception ex)
        {
            // Something else went wrong. Display the error message.
            Console.WriteLine($"Error: {ex.Message}");
            return null;
        }
    }

    /// <summary>
    /// Create a new S3 bucket.
    /// </summary>
    /// <param name="bucketName">The name for the new bucket.</param>
    /// <returns>A Boolean value indicating whether the action completed
    /// successfully.</returns>
    public async Task<bool> PutBucketAsync(string bucketName)
    {
        var response = await _s3Service.PutBucketAsync(new PutBucketRequest { BucketName = bucketName });
        return response.HttpStatusCode == HttpStatusCode.OK;
    }

    /// <summary>
    /// Update the client objects with new client objects. This is available
    /// because the scenario uses the methods of this class without and then
    /// with the proper permissions to list S3 buckets.
    /// </summary>
    /// <param name="s3Service">The Amazon S3 client object.</param>
    /// <param name="stsService">The AWS STS client object.</param>
    public void UpdateClients(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService)
    {
        _s3Service = s3Service;
        _stsService = stsService;
    }
}


namespace IamScenariosCommon;

public class UIWrapper
{
    public readonly string SepBar = new('-', Console.WindowWidth);

    /// <summary>
    /// Show information about the IAM Groups scenario.
    /// </summary>
    public void DisplayGroupsOverview()
    {
        Console.Clear();

        DisplayTitle("Welcome to the IAM Groups Demo");
        Console.WriteLine("This example application does the following:");
        Console.WriteLine("\t1. Creates an Amazon Identity and Access Management (IAM) group.");
        Console.WriteLine("\t2. Adds an IAM policy to the IAM group giving it full access to Amazon S3.");
        Console.WriteLine("\t3. Creates a new IAM user.");
        Console.WriteLine("\t4. Creates an IAM access key for the user.");
        Console.WriteLine("\t5. Adds the user to the IAM group.");
        Console.WriteLine("\t6. Lists the buckets on the account.");
        Console.WriteLine("\t7. Proves that the user has full Amazon S3 access by creating a bucket.");
        Console.WriteLine("\t8. List the buckets again to show the new bucket.");
        Console.WriteLine("\t9. Cleans up all the resources created.");
    }

    /// <summary>
    /// Show information about the IAM Basics scenario.
    /// </summary>
    public void DisplayBasicsOverview()
    {
        Console.Clear();

        DisplayTitle("Welcome to IAM Basics");
        Console.WriteLine("This example application does the following:");
        Console.WriteLine("\t1. Creates a user with no permissions.");
        Console.WriteLine("\t2. Creates a role and policy that grant s3:ListAllMyBuckets permission.");
        Console.WriteLine("\t3. Grants the user permission to assume the role.");
        Console.WriteLine("\t4. Creates an S3 client object as the user and tries to list buckets (this will fail).");
        Console.WriteLine("\t5. Gets temporary credentials by assuming the role.");
        Console.WriteLine("\t6. Creates a new S3 client object with the temporary credentials and lists the buckets (this will succeed).");
        Console.WriteLine("\t7. Deletes all the resources.");
    }

    /// <summary>
    /// Display a message and wait until the user presses enter.
    /// </summary>
    public void PressEnter()
    {
        Console.Write("\nPress <Enter> to continue. ");
        _ = Console.ReadLine();
        Console.WriteLine();
    }

    /// <summary>
    /// Pad a string with spaces to center it on the console display.
    /// </summary>
    /// <param name="strToCenter">The string to be centered.</param>
    /// <returns>The padded string.</returns>
    public string CenterString(string strToCenter)
    {
        var padAmount = (Console.WindowWidth - strToCenter.Length) / 2;
        var leftPad = new string(' ', padAmount);
        return $"{leftPad}{strToCenter}";
    }

    /// <summary>
    /// Display a line of hyphens, the centered text of the title, and another
    /// line of hyphens.
    /// </summary>
    /// <param name="strTitle">The string to be displayed.</param>
    public void DisplayTitle(string strTitle)
    {
        Console.WriteLine(SepBar);
        Console.WriteLine(CenterString(strTitle));
        Console.WriteLine(SepBar);
    }

    /// <summary>
    /// Display a countdown and wait for a number of seconds.
    /// </summary>
    /// <param name="numSeconds">The number of seconds to wait.</param>
    public void WaitABit(int numSeconds, string msg)
    {
        Console.WriteLine(msg);

        // Wait for the requested number of seconds.
        for (int i = numSeconds; i > 0; i--)
        {
            System.Threading.Thread.Sleep(1000);
            Console.Write($"{i}...");
        }

        PressEnter();
    }
}
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *referencia de la API de AWS SDK para .NET*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Bash ]

**AWS CLI con Bash script**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/iam#code-examples). 

```
###############################################################################
# function iam_create_user_assume_role
#
# Scenario to create an IAM user, create an IAM role, and apply the role to the user.
#
#     "IAM access" permissions are needed to run this code.
#     "STS assume role" permissions are needed to run this code. (Note: It might be necessary to
#           create a custom policy).
#
# Returns:
#       0 - If successful.
#       1 - If an error occurred.
###############################################################################
function iam_create_user_assume_role() {
  {
    if [ "$IAM_OPERATIONS_SOURCED" != "True" ]; then

      source ./iam_operations.sh
    fi
  }

  echo_repeat "*" 88
  echo "Welcome to the IAM create user and assume role demo."
  echo
  echo "This demo will create an IAM user, create an IAM role, and apply the role to the user."
  echo_repeat "*" 88
  echo

  echo -n "Enter a name for a new IAM user: "
  get_input
  user_name=$get_input_result

  local user_arn
  user_arn=$(iam_create_user -u "$user_name")

  # shellcheck disable=SC2181
  if [[ ${?} == 0 ]]; then
    echo "Created demo IAM user named $user_name"
  else
    errecho "$user_arn"
    errecho "The user failed to create. This demo will exit."
    return 1
  fi

  local access_key_response
  access_key_response=$(iam_create_user_access_key -u "$user_name")
  # shellcheck disable=SC2181
  if [[ ${?} != 0 ]]; then
    errecho "The access key failed to create. This demo will exit."
    clean_up "$user_name"
    return 1
  fi

  IFS=$'\t ' read -r -a access_key_values <<<"$access_key_response"
  local key_name=${access_key_values[0]}
  local key_secret=${access_key_values[1]}

  echo "Created access key named $key_name"

  echo "Wait 10 seconds for the user to be ready."
  sleep 10
  echo_repeat "*" 88
  echo

  local iam_role_name
  iam_role_name=$(generate_random_name "test-role")
  echo "Creating a role named $iam_role_name with user $user_name as the principal."

  local assume_role_policy_document="{
    \"Version\": \"2012-10-17\",
    \"Statement\": [{
        \"Effect\": \"Allow\",
        \"Principal\": {\"AWS\": \"$user_arn\"},
        \"Action\": \"sts:AssumeRole\"
        }]
    }"

  local role_arn
  role_arn=$(iam_create_role -n "$iam_role_name" -p "$assume_role_policy_document")

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Created IAM role named $iam_role_name"
  else
    errecho "The role failed to create. This demo will exit."
    clean_up "$user_name" "$key_name"
    return 1
  fi

  local policy_name
  policy_name=$(generate_random_name "test-policy")
  local policy_document="{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]}"

  local policy_arn
  policy_arn=$(iam_create_policy -n "$policy_name" -p "$policy_document")
  # shellcheck disable=SC2181
  if [[ ${?} == 0 ]]; then
    echo "Created  IAM policy named $policy_name"
  else
    errecho "The policy failed to create."
    clean_up "$user_name" "$key_name" "$iam_role_name"
    return 1
  fi

  if (iam_attach_role_policy -n "$iam_role_name" -p "$policy_arn"); then
    echo "Attached policy $policy_arn to role $iam_role_name"
  else
    errecho "The policy failed to attach."
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn"
    return 1
  fi

  local assume_role_policy_document="{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"$role_arn\"}]}"

  local assume_role_policy_name
  assume_role_policy_name=$(generate_random_name "test-assume-role-")

  # shellcheck disable=SC2181
  local assume_role_policy_arn
  assume_role_policy_arn=$(iam_create_policy -n "$assume_role_policy_name" -p "$assume_role_policy_document")
  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Created  IAM policy named $assume_role_policy_name for sts assume role"
  else
    errecho "The policy failed to create."
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn"
    return 1
  fi

  echo "Wait 10 seconds to give AWS time to propagate these new resources and connections."
  sleep 10
  echo_repeat "*" 88
  echo

  echo "Try to list buckets without the new user assuming the role."
  echo_repeat "*" 88
  echo

  # Set the environment variables for the created user.
  # bashsupport disable=BP2001
  export AWS_ACCESS_KEY_ID=$key_name
  # bashsupport disable=BP2001
  export AWS_SECRET_ACCESS_KEY=$key_secret

  local buckets
  buckets=$(s3_list_buckets)

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    local bucket_count
    bucket_count=$(echo "$buckets" | wc -w | xargs)
    echo "There are $bucket_count buckets in the account. This should not have happened."
  else
    errecho "Because the role with permissions has not been assumed, listing buckets failed."
  fi

  echo
  echo_repeat "*" 88
  echo "Now assume the role $iam_role_name and list the buckets."
  echo_repeat "*" 88
  echo

  local credentials

  credentials=$(sts_assume_role -r "$role_arn" -n "AssumeRoleDemoSession")
  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Assumed role $iam_role_name"
  else
    errecho "Failed to assume role."
    export AWS_ACCESS_KEY_ID=""
    export AWS_SECRET_ACCESS_KEY=""
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"
    return 1
  fi

  IFS=$'\t ' read -r -a credentials <<<"$credentials"

  export AWS_ACCESS_KEY_ID=${credentials[0]}
  export AWS_SECRET_ACCESS_KEY=${credentials[1]}
  # bashsupport disable=BP2001
  export AWS_SESSION_TOKEN=${credentials[2]}

  buckets=$(s3_list_buckets)

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    local bucket_count
    bucket_count=$(echo "$buckets" | wc -w | xargs)
    echo "There are $bucket_count buckets in the account. Listing buckets succeeded because of "
    echo "the assumed role."
  else
    errecho "Failed to list buckets. This should not happen."
    export AWS_ACCESS_KEY_ID=""
    export AWS_SECRET_ACCESS_KEY=""
    export AWS_SESSION_TOKEN=""
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"
    return 1
  fi

  local result=0
  export AWS_ACCESS_KEY_ID=""
  export AWS_SECRET_ACCESS_KEY=""

  echo
  echo_repeat "*" 88
  echo "The created resources will now be deleted."
  echo_repeat "*" 88
  echo

  clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"

  # shellcheck disable=SC2181
  if [[ ${?} -ne 0 ]]; then
    result=1
  fi

  return $result
}
```
Las funciones de IAM que se usan en este escenario.  

```
###############################################################################
# function iam_user_exists
#
# This function checks to see if the specified AWS Identity and Access Management (IAM) user already exists.
#
# Parameters:
#       $1 - The name of the IAM user to check.
#
# Returns:
#       0 - If the user already exists.
#       1 - If the user doesn't exist.
###############################################################################
function iam_user_exists() {
  local user_name
  user_name=$1

  # Check whether the IAM user already exists.
  # We suppress all output - we're interested only in the return code.

  local errors
  errors=$(aws iam get-user \
    --user-name "$user_name" 2>&1 >/dev/null)

  local error_code=${?}

  if [[ $error_code -eq 0 ]]; then
    return 0 # 0 in Bash script means true.
  else
    if [[ $errors != *"error"*"(NoSuchEntity)"* ]]; then
      aws_cli_error_log $error_code
      errecho "Error calling iam get-user $errors"
    fi

    return 1 # 1 in Bash script means false.
  fi
}

###############################################################################
# function iam_create_user
#
# This function creates the specified IAM user, unless
# it already exists.
#
# Parameters:
#       -u user_name  -- The name of the user to create.
#
# Returns:
#       The ARN of the user.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_user() {
  local user_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user"
    echo "Creates an AWS Identity and Access Management (IAM) user. You must supply a username:"
    echo "  -u user_name    The name of the user. It must be unique within the account."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    User name:   $user_name"
  iecho ""

  # If the user already exists, we don't want to try to create it.
  if (iam_user_exists "$user_name"); then
    errecho "ERROR: A user with that name already exists in the account."
    return 1
  fi

  response=$(aws iam create-user --user-name "$user_name" \
    --output text \
    --query 'User.Arn')

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-user operation failed.$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_create_user_access_key
#
# This function creates an IAM access key for the specified user.
#
# Parameters:
#       -u user_name -- The name of the IAM user.
#       [-f file_name] -- The optional file name for the access key output.
#
# Returns:
#       [access_key_id access_key_secret]
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_user_access_key() {
  local user_name file_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) key pair."
    echo "  -u user_name   The name of the IAM user."
    echo "  [-f file_name]   Optional file name for the access key output."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:f:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      f) file_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  response=$(aws iam create-access-key \
    --user-name "$user_name" \
    --output text)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-access-key operation failed.$response"
    return 1
  fi

  if [[ -n "$file_name" ]]; then
    echo "$response" >"$file_name"
  fi

  local key_id key_secret
  # shellcheck disable=SC2086
  key_id=$(echo $response | cut -f 2 -d ' ')
  # shellcheck disable=SC2086
  key_secret=$(echo $response | cut -f 4 -d ' ')

  echo "$key_id $key_secret"

  return 0
}

###############################################################################
# function iam_create_role
#
# This function creates an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_json -- The assume role policy document.
#
# Returns:
#       The ARN of the role.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_role() {
  local role_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_json -- The assume role policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-role \
    --role-name "$role_name" \
    --assume-role-policy-document "$policy_document" \
    --output text \
    --query Role.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-role operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_create_policy
#
# This function creates an IAM policy.
#
# Parameters:
#       -n policy_name -- The name of the IAM policy.
#       -p policy_json -- The policy document.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_policy() {
  local policy_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_policy"
    echo "Creates an AWS Identity and Access Management (IAM) policy."
    echo "  -n policy_name   The name of the IAM policy."
    echo "  -p policy_json -- The policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) policy_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$policy_name" ]]; then
    errecho "ERROR: You must provide a policy name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-policy \
    --policy-name "$policy_name" \
    --policy-document "$policy_document" \
    --output text \
    --query Policy.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"
}

###############################################################################
# function iam_attach_role_policy
#
# This function attaches an IAM policy to a tole.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_ARN -- The IAM policy document ARN..
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_attach_role_policy() {
  local role_name policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_attach_role_policy"
    echo "Attaches an AWS Identity and Access Management (IAM) policy to an IAM role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_ARN -- The IAM policy document ARN."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy ARN with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam attach-role-policy \
    --role-name "$role_name" \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports attach-role-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_detach_role_policy
#
# This function detaches an IAM policy to a tole.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_ARN -- The IAM policy document ARN..
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_detach_role_policy() {
  local role_name policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_detach_role_policy"
    echo "Detaches an AWS Identity and Access Management (IAM) policy to an IAM role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_ARN -- The IAM policy document ARN."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy ARN with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam detach-role-policy \
    --role-name "$role_name" \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports detach-role-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_delete_policy
#
# This function deletes an IAM policy.
#
# Parameters:
#       -n policy_arn -- The name of the IAM policy arn.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_policy() {
  local policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_policy"
    echo "Deletes an AWS Identity and Access Management (IAM) policy"
    echo "  -n policy_arn -- The name of the IAM policy arn."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:h" option; do
    case "${option}" in
      n) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy arn with the -n parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Policy arn:  $policy_arn"
  iecho ""

  response=$(aws iam delete-policy \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-policy operation failed.\n$response"
    return 1
  fi

  iecho "delete-policy response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_role
#
# This function deletes an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_role() {
  local role_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_role"
    echo "Deletes an AWS Identity and Access Management (IAM) role"
    echo "  -n role_name -- The name of the IAM role."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  echo "role_name:$role_name"
  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Role name:  $role_name"
  iecho ""

  response=$(aws iam delete-role \
    --role-name "$role_name")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-role operation failed.\n$response"
    return 1
  fi

  iecho "delete-role response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_access_key
#
# This function deletes an IAM access key for the specified IAM user.
#
# Parameters:
#       -u user_name  -- The name of the user.
#       -k access_key -- The access key to delete.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_access_key() {
  local user_name access_key response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_access_key"
    echo "Deletes an AWS Identity and Access Management (IAM) access key for the specified IAM user"
    echo "  -u user_name    The name of the user."
    echo "  -k access_key   The access key to delete."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:k:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      k) access_key="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  if [[ -z "$access_key" ]]; then
    errecho "ERROR: You must provide an access key with the -k parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Username:   $user_name"
  iecho "    Access key:   $access_key"
  iecho ""

  response=$(aws iam delete-access-key \
    --user-name "$user_name" \
    --access-key-id "$access_key")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-access-key operation failed.\n$response"
    return 1
  fi

  iecho "delete-access-key response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_user
#
# This function deletes the specified IAM user.
#
# Parameters:
#       -u user_name  -- The name of the user to create.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_user() {
  local user_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_user"
    echo "Deletes an AWS Identity and Access Management (IAM) user. You must supply a username:"
    echo "  -u user_name    The name of the user."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    User name:   $user_name"
  iecho ""

  # If the user does not exist, we don't want to try to delete it.
  if (! iam_user_exists "$user_name"); then
    errecho "ERROR: A user with that name does not exist in the account."
    return 1
  fi

  response=$(aws iam delete-user \
    --user-name "$user_name")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-user operation failed.$response"
    return 1
  fi

  iecho "delete-user response:$response"
  iecho

  return 0
}
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *Referencia de comandos de AWS CLI*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/PutUserPolicy)

------
#### [ C\$1\$1 ]

**SDK para C\$1\$1**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/iam#code-examples). 

```
namespace AwsDoc {
    namespace IAM {
  
        //! Cleanup by deleting created entities.
        /*!
          \sa DeleteCreatedEntities
          \param client: IAM client.
          \param role: IAM role.
          \param user: IAM user.
          \param policy: IAM policy.
        */
        static bool DeleteCreatedEntities(const Aws::IAM::IAMClient &client,
                                          const Aws::IAM::Model::Role &role,
                                          const Aws::IAM::Model::User &user,
                                          const Aws::IAM::Model::Policy &policy);
    }

    static const int LIST_BUCKETS_WAIT_SEC = 20;

    static const char ALLOCATION_TAG[] = "example_code";
}

//! Scenario to create an IAM user, create an IAM role, and apply the role to the user.
// "IAM access" permissions are needed to run this code.
// "STS assume role" permissions are needed to run this code. (Note: It might be necessary to
//    create a custom policy).
/*!
  \sa iamCreateUserAssumeRoleScenario
  \param clientConfig: Aws client configuration.
  \return bool: Successful completion.
*/
bool AwsDoc::IAM::iamCreateUserAssumeRoleScenario(
        const Aws::Client::ClientConfiguration &clientConfig) {

    Aws::IAM::IAMClient client(clientConfig);
    Aws::IAM::Model::User user;
    Aws::IAM::Model::Role role;
    Aws::IAM::Model::Policy policy;

    // 1. Create a user.
    {
        Aws::IAM::Model::CreateUserRequest request;
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String userName = "iam-demo-user-" +
                               Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetUserName(userName);

        Aws::IAM::Model::CreateUserOutcome outcome = client.CreateUser(request);
        if (!outcome.IsSuccess()) {
            std::cout << "Error creating IAM user " << userName << ":" <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }
        else {
            std::cout << "Successfully created IAM user " << userName << std::endl;
        }

        user = outcome.GetResult().GetUser();
    }

    // 2. Create a role.
    {
        // Get the IAM user for the current client in order to access its ARN.
        Aws::String iamUserArn;
        {
            Aws::IAM::Model::GetUserRequest request;
            Aws::IAM::Model::GetUserOutcome outcome = client.GetUser(request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error getting Iam user. " <<
                          outcome.GetError().GetMessage() << std::endl;

                DeleteCreatedEntities(client, role, user, policy);
                return false;
            }
            else {
                std::cout << "Successfully retrieved Iam user "
                          << outcome.GetResult().GetUser().GetUserName()
                          << std::endl;
            }

            iamUserArn = outcome.GetResult().GetUser().GetArn();
        }

        Aws::IAM::Model::CreateRoleRequest request;

        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String roleName = "iam-demo-role-" +
                               Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetRoleName(roleName);

        // Build policy document for role.
        Aws::Utils::Document jsonStatement;
        jsonStatement.WithString("Effect", "Allow");

        Aws::Utils::Document jsonPrincipal;
        jsonPrincipal.WithString("AWS", iamUserArn);
        jsonStatement.WithObject("Principal", jsonPrincipal);
        jsonStatement.WithString("Action", "sts:AssumeRole");
        jsonStatement.WithObject("Condition", Aws::Utils::Document());

        Aws::Utils::Document policyDocument;
        policyDocument.WithString("Version", "2012-10-17");

        Aws::Utils::Array<Aws::Utils::Document> statements(1);
        statements[0] = jsonStatement;
        policyDocument.WithArray("Statement", statements);

        std::cout << "Setting policy for role\n   "
                  << policyDocument.View().WriteCompact() << std::endl;

        // Set role policy document as JSON string.
        request.SetAssumeRolePolicyDocument(policyDocument.View().WriteCompact());

        Aws::IAM::Model::CreateRoleOutcome outcome = client.CreateRole(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating role. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully created a role with name " << roleName
                      << std::endl;
        }

        role = outcome.GetResult().GetRole();
    }

    // 3. Create an IAM policy.
    {
        Aws::IAM::Model::CreatePolicyRequest request;
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String policyName = "iam-demo-policy-" +
                                 Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetPolicyName(policyName);

        // Build IAM policy document.
        Aws::Utils::Document jsonStatement;
        jsonStatement.WithString("Effect", "Allow");
        jsonStatement.WithString("Action", "s3:ListAllMyBuckets");
        jsonStatement.WithString("Resource", "arn:aws:s3:::*");

        Aws::Utils::Document policyDocument;
        policyDocument.WithString("Version", "2012-10-17");

        Aws::Utils::Array<Aws::Utils::Document> statements(1);
        statements[0] = jsonStatement;
        policyDocument.WithArray("Statement", statements);

        std::cout << "Creating a policy.\n   " << policyDocument.View().WriteCompact()
                  << std::endl;

        // Set IAM policy document as JSON string.
        request.SetPolicyDocument(policyDocument.View().WriteCompact());

        Aws::IAM::Model::CreatePolicyOutcome outcome = client.CreatePolicy(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating policy. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully created a policy with name, " << policyName <<
                      "." << std::endl;
        }

        policy = outcome.GetResult().GetPolicy();
    }

    // 4. Assume the new role using the AWS Security Token Service (STS).
    Aws::STS::Model::Credentials credentials;
    {
        Aws::STS::STSClient stsClient(clientConfig);

        Aws::STS::Model::AssumeRoleRequest request;
        request.SetRoleArn(role.GetArn());
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String roleSessionName = "iam-demo-role-session-" +
                                      Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetRoleSessionName(roleSessionName);

        Aws::STS::Model::AssumeRoleOutcome assumeRoleOutcome;

        // Repeatedly call AssumeRole, because there is often a delay
        // before the role is available to be assumed.
        // Repeat at most 20 times when access is denied.
        int count = 0;
        while (true) {
            assumeRoleOutcome = stsClient.AssumeRole(request);
            if (!assumeRoleOutcome.IsSuccess()) {
                if (count > 20 ||
                    assumeRoleOutcome.GetError().GetErrorType() !=
                    Aws::STS::STSErrors::ACCESS_DENIED) {
                    std::cerr << "Error assuming role after 20 tries. " <<
                              assumeRoleOutcome.GetError().GetMessage() << std::endl;

                    DeleteCreatedEntities(client, role, user, policy);
                    return false;
                }
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
            else {
                std::cout << "Successfully assumed the role after " << count
                          << " seconds." << std::endl;
                break;
            }
            count++;
        }

        credentials = assumeRoleOutcome.GetResult().GetCredentials();
    }


    // 5. List objects in the bucket (This should fail).
    {
        Aws::S3::S3Client s3Client(
                Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(),
                                          credentials.GetSecretAccessKey(),
                                          credentials.GetSessionToken()),
                Aws::MakeShared<Aws::S3::S3EndpointProvider>(ALLOCATION_TAG),
                clientConfig);
        Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets();
        if (!listBucketsOutcome.IsSuccess()) {
            if (listBucketsOutcome.GetError().GetErrorType() !=
                Aws::S3::S3Errors::ACCESS_DENIED) {
                std::cerr << "Could not lists buckets. " <<
                          listBucketsOutcome.GetError().GetMessage() << std::endl;
            }
            else {
                std::cout
                        << "Access to list buckets denied because privileges have not been applied."
                        << std::endl;
            }
        }
        else {
            std::cerr
                    << "Successfully retrieved bucket lists when this should not happen."
                    << std::endl;
        }
    }

    // 6. Attach the policy to the role.
    {
        Aws::IAM::Model::AttachRolePolicyRequest request;
        request.SetRoleName(role.GetRoleName());
        request.WithPolicyArn(policy.GetArn());

        Aws::IAM::Model::AttachRolePolicyOutcome outcome = client.AttachRolePolicy(
                request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating policy. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully attached the policy with name, "
                      << policy.GetPolicyName() <<
                      ", to the role, " << role.GetRoleName() << "." << std::endl;
        }
    }

    int count = 0;
    // 7. List objects in the bucket (this should succeed).
    // Repeatedly call ListBuckets, because there is often a delay
    // before the policy with ListBucket permissions has been applied to the role.
    // Repeat at most LIST_BUCKETS_WAIT_SEC times when access is denied.
    while (true) {
        Aws::S3::S3Client s3Client(
                Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(),
                                          credentials.GetSecretAccessKey(),
                                          credentials.GetSessionToken()),
                Aws::MakeShared<Aws::S3::S3EndpointProvider>(ALLOCATION_TAG),
                clientConfig);
        Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets();
        if (!listBucketsOutcome.IsSuccess()) {
            if ((count > LIST_BUCKETS_WAIT_SEC) ||
                listBucketsOutcome.GetError().GetErrorType() !=
                Aws::S3::S3Errors::ACCESS_DENIED) {
                std::cerr << "Could not lists buckets after " << LIST_BUCKETS_WAIT_SEC << " seconds. " <<
                          listBucketsOutcome.GetError().GetMessage() << std::endl;
                DeleteCreatedEntities(client, role, user, policy);
                return false;
            }

            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        else {

            std::cout << "Successfully retrieved bucket lists after " << count
                      << " seconds." << std::endl;
            break;
        }
        count++;
    }

    // 8. Delete all the created resources.
    return DeleteCreatedEntities(client, role, user, policy);
}

bool AwsDoc::IAM::DeleteCreatedEntities(const Aws::IAM::IAMClient &client,
                                        const Aws::IAM::Model::Role &role,
                                        const Aws::IAM::Model::User &user,
                                        const Aws::IAM::Model::Policy &policy) {
    bool result = true;
    if (policy.ArnHasBeenSet()) {
        // Detach the policy from the role.
        {
            Aws::IAM::Model::DetachRolePolicyRequest request;
            request.SetPolicyArn(policy.GetArn());
            request.SetRoleName(role.GetRoleName());

            Aws::IAM::Model::DetachRolePolicyOutcome outcome = client.DetachRolePolicy(
                    request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error Detaching policy from roles. " <<
                          outcome.GetError().GetMessage() << std::endl;
                result = false;
            }
            else {
                std::cout << "Successfully detached the policy with arn "
                          << policy.GetArn()
                          << " from role " << role.GetRoleName() << "." << std::endl;
            }
        }

        // Delete the policy.
        {
            Aws::IAM::Model::DeletePolicyRequest request;
            request.WithPolicyArn(policy.GetArn());

            Aws::IAM::Model::DeletePolicyOutcome outcome = client.DeletePolicy(request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error deleting policy. " <<
                          outcome.GetError().GetMessage() << std::endl;
                result = false;
            }
            else {
                std::cout << "Successfully deleted the policy with arn "
                          << policy.GetArn() << std::endl;
            }
        }

    }

    if (role.RoleIdHasBeenSet()) {
        // Delete the role.
        Aws::IAM::Model::DeleteRoleRequest request;
        request.SetRoleName(role.GetRoleName());

        Aws::IAM::Model::DeleteRoleOutcome outcome = client.DeleteRole(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error deleting role. " <<
                      outcome.GetError().GetMessage() << std::endl;
            result = false;
        }
        else {
            std::cout << "Successfully deleted the role with name "
                      << role.GetRoleName() << std::endl;
        }
    }

    if (user.ArnHasBeenSet()) {
        // Delete the user.
        Aws::IAM::Model::DeleteUserRequest request;
        request.WithUserName(user.GetUserName());

        Aws::IAM::Model::DeleteUserOutcome outcome = client.DeleteUser(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error deleting user. " <<
                      outcome.GetError().GetMessage() << std::endl;
            result = false;
        }
        else {
            std::cout << "Successfully deleted the user with name "
                      << user.GetUserName() << std::endl;
        }
    }

    return result;
}
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *referencia de la API de AWS SDK para C\$1\$1*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/PutUserPolicy)

------
#### [ Go ]

**SDK para Go V2**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/iam#code-examples). 
Ejecute un escenario interactivo en un símbolo del sistema.  

```
import (
	"context"
	"errors"
	"fmt"
	"log"
	"math/rand"
	"strings"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/sts"
	"github.com/aws/smithy-go"
	"github.com/awsdocs/aws-doc-sdk-examples/gov2/demotools"
	"github.com/awsdocs/aws-doc-sdk-examples/gov2/iam/actions"
)

// AssumeRoleScenario shows you how to use the AWS Identity and Access Management (IAM)
// service to perform the following actions:
//
//  1. Create a user who has no permissions.
//  2. Create a role that grants permission to list Amazon Simple Storage Service
//     (Amazon S3) buckets for the account.
//  3. Add a policy to let the user assume the role.
//  4. Try and fail to list buckets without permissions.
//  5. Assume the role and list S3 buckets using temporary credentials.
//  6. Delete the policy, role, and user.
type AssumeRoleScenario struct {
	sdkConfig      aws.Config
	accountWrapper actions.AccountWrapper
	policyWrapper  actions.PolicyWrapper
	roleWrapper    actions.RoleWrapper
	userWrapper    actions.UserWrapper
	questioner     demotools.IQuestioner
	helper         IScenarioHelper
	isTestRun      bool
}

// NewAssumeRoleScenario constructs an AssumeRoleScenario instance from a configuration.
// It uses the specified config to get an IAM client and create wrappers for the actions
// used in the scenario.
func NewAssumeRoleScenario(sdkConfig aws.Config, questioner demotools.IQuestioner,
	helper IScenarioHelper) AssumeRoleScenario {
	iamClient := iam.NewFromConfig(sdkConfig)
	return AssumeRoleScenario{
		sdkConfig:      sdkConfig,
		accountWrapper: actions.AccountWrapper{IamClient: iamClient},
		policyWrapper:  actions.PolicyWrapper{IamClient: iamClient},
		roleWrapper:    actions.RoleWrapper{IamClient: iamClient},
		userWrapper:    actions.UserWrapper{IamClient: iamClient},
		questioner:     questioner,
		helper:         helper,
	}
}

// addTestOptions appends the API options specified in the original configuration to
// another configuration. This is used to attach the middleware stubber to clients
// that are constructed during the scenario, which is needed for unit testing.
func (scenario AssumeRoleScenario) addTestOptions(scenarioConfig *aws.Config) {
	if scenario.isTestRun {
		scenarioConfig.APIOptions = append(scenarioConfig.APIOptions, scenario.sdkConfig.APIOptions...)
	}
}

// Run runs the interactive scenario.
func (scenario AssumeRoleScenario) Run(ctx context.Context) {
	defer func() {
		if r := recover(); r != nil {
			log.Printf("Something went wrong with the demo.\n")
			log.Println(r)
		}
	}()

	log.Println(strings.Repeat("-", 88))
	log.Println("Welcome to the AWS Identity and Access Management (IAM) assume role demo.")
	log.Println(strings.Repeat("-", 88))

	user := scenario.CreateUser(ctx)
	accessKey := scenario.CreateAccessKey(ctx, user)
	role := scenario.CreateRoleAndPolicies(ctx, user)
	noPermsConfig := scenario.ListBucketsWithoutPermissions(ctx, accessKey)
	scenario.ListBucketsWithAssumedRole(ctx, noPermsConfig, role)
	scenario.Cleanup(ctx, user, role)

	log.Println(strings.Repeat("-", 88))
	log.Println("Thanks for watching!")
	log.Println(strings.Repeat("-", 88))
}

// CreateUser creates a new IAM user. This user has no permissions.
func (scenario AssumeRoleScenario) CreateUser(ctx context.Context) *types.User {
	log.Println("Let's create an example user with no permissions.")
	userName := scenario.questioner.Ask("Enter a name for the example user:", demotools.NotEmpty{})
	user, err := scenario.userWrapper.GetUser(ctx, userName)
	if err != nil {
		panic(err)
	}
	if user == nil {
		user, err = scenario.userWrapper.CreateUser(ctx, userName)
		if err != nil {
			panic(err)
		}
		log.Printf("Created user %v.\n", *user.UserName)
	} else {
		log.Printf("User %v already exists.\n", *user.UserName)
	}
	log.Println(strings.Repeat("-", 88))
	return user
}

// CreateAccessKey creates an access key for the user.
func (scenario AssumeRoleScenario) CreateAccessKey(ctx context.Context, user *types.User) *types.AccessKey {
	accessKey, err := scenario.userWrapper.CreateAccessKeyPair(ctx, *user.UserName)
	if err != nil {
		panic(err)
	}
	log.Printf("Created access key %v for your user.", *accessKey.AccessKeyId)
	log.Println("Waiting a few seconds for your user to be ready...")
	scenario.helper.Pause(10)
	log.Println(strings.Repeat("-", 88))
	return accessKey
}

// CreateRoleAndPolicies creates a policy that grants permission to list S3 buckets for
// the current account and attaches the policy to a newly created role. It also adds an
// inline policy to the specified user that grants the user permission to assume the role.
func (scenario AssumeRoleScenario) CreateRoleAndPolicies(ctx context.Context, user *types.User) *types.Role {
	log.Println("Let's create a role and policy that grant permission to list S3 buckets.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	listBucketsRole, err := scenario.roleWrapper.CreateRole(ctx, scenario.helper.GetName(), *user.Arn)
	if err != nil {
		panic(err)
	}
	log.Printf("Created role %v.\n", *listBucketsRole.RoleName)
	listBucketsPolicy, err := scenario.policyWrapper.CreatePolicy(
		ctx, scenario.helper.GetName(), []string{"s3:ListAllMyBuckets"}, "arn:aws:s3:::*")
	if err != nil {
		panic(err)
	}
	log.Printf("Created policy %v.\n", *listBucketsPolicy.PolicyName)
	err = scenario.roleWrapper.AttachRolePolicy(ctx, *listBucketsPolicy.Arn, *listBucketsRole.RoleName)
	if err != nil {
		panic(err)
	}
	log.Printf("Attached policy %v to role %v.\n", *listBucketsPolicy.PolicyName,
		*listBucketsRole.RoleName)
	err = scenario.userWrapper.CreateUserPolicy(ctx, *user.UserName, scenario.helper.GetName(),
		[]string{"sts:AssumeRole"}, *listBucketsRole.Arn)
	if err != nil {
		panic(err)
	}
	log.Printf("Created an inline policy for user %v that lets the user assume the role.\n",
		*user.UserName)
	log.Println("Let's give AWS a few seconds to propagate these new resources and connections...")
	scenario.helper.Pause(10)
	log.Println(strings.Repeat("-", 88))
	return listBucketsRole
}

// ListBucketsWithoutPermissions creates an Amazon S3 client from the user's access key
// credentials and tries to list buckets for the account. Because the user does not have
// permission to perform this action, the action fails.
func (scenario AssumeRoleScenario) ListBucketsWithoutPermissions(ctx context.Context, accessKey *types.AccessKey) *aws.Config {
	log.Println("Let's try to list buckets without permissions. This should return an AccessDenied error.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	noPermsConfig, err := config.LoadDefaultConfig(ctx,
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
			*accessKey.AccessKeyId, *accessKey.SecretAccessKey, ""),
		))
	if err != nil {
		panic(err)
	}

	// Add test options if this is a test run. This is needed only for testing purposes.
	scenario.addTestOptions(&noPermsConfig)

	s3Client := s3.NewFromConfig(noPermsConfig)
	_, err = s3Client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		// The SDK for Go does not model the AccessDenied error, so check ErrorCode directly.
		var ae smithy.APIError
		if errors.As(err, &ae) {
			switch ae.ErrorCode() {
			case "AccessDenied":
				log.Println("Got AccessDenied error, which is the expected result because\n" +
					"the ListBuckets call was made without permissions.")
			default:
				log.Println("Expected AccessDenied, got something else.")
				panic(err)
			}
		}
	} else {
		log.Println("Expected AccessDenied error when calling ListBuckets without permissions,\n" +
			"but the call succeeded. Continuing the example anyway...")
	}
	log.Println(strings.Repeat("-", 88))
	return &noPermsConfig
}

// ListBucketsWithAssumedRole performs the following actions:
//
//  1. Creates an AWS Security Token Service (AWS STS) client from the config created from
//     the user's access key credentials.
//  2. Gets temporary credentials by assuming the role that grants permission to list the
//     buckets.
//  3. Creates an Amazon S3 client from the temporary credentials.
//  4. Lists buckets for the account. Because the temporary credentials are generated by
//     assuming the role that grants permission, the action succeeds.
func (scenario AssumeRoleScenario) ListBucketsWithAssumedRole(ctx context.Context, noPermsConfig *aws.Config, role *types.Role) {
	log.Println("Let's assume the role that grants permission to list buckets and try again.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	stsClient := sts.NewFromConfig(*noPermsConfig)
	tempCredentials, err := stsClient.AssumeRole(ctx, &sts.AssumeRoleInput{
		RoleArn:         role.Arn,
		RoleSessionName: aws.String("AssumeRoleExampleSession"),
		DurationSeconds: aws.Int32(900),
	})
	if err != nil {
		log.Printf("Couldn't assume role %v.\n", *role.RoleName)
		panic(err)
	}
	log.Printf("Assumed role %v, got temporary credentials.\n", *role.RoleName)
	assumeRoleConfig, err := config.LoadDefaultConfig(ctx,
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
			*tempCredentials.Credentials.AccessKeyId,
			*tempCredentials.Credentials.SecretAccessKey,
			*tempCredentials.Credentials.SessionToken),
		),
	)
	if err != nil {
		panic(err)
	}

	// Add test options if this is a test run. This is needed only for testing purposes.
	scenario.addTestOptions(&assumeRoleConfig)

	s3Client := s3.NewFromConfig(assumeRoleConfig)
	result, err := s3Client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		log.Println("Couldn't list buckets with assumed role credentials.")
		panic(err)
	}
	log.Println("Successfully called ListBuckets with assumed role credentials, \n" +
		"here are some of them:")
	for i := 0; i < len(result.Buckets) && i < 5; i++ {
		log.Printf("\t%v\n", *result.Buckets[i].Name)
	}
	log.Println(strings.Repeat("-", 88))
}

// Cleanup deletes all resources created for the scenario.
func (scenario AssumeRoleScenario) Cleanup(ctx context.Context, user *types.User, role *types.Role) {
	if scenario.questioner.AskBool(
		"Do you want to delete the resources created for this example? (y/n)", "y",
	) {
		policies, err := scenario.roleWrapper.ListAttachedRolePolicies(ctx, *role.RoleName)
		if err != nil {
			panic(err)
		}
		for _, policy := range policies {
			err = scenario.roleWrapper.DetachRolePolicy(ctx, *role.RoleName, *policy.PolicyArn)
			if err != nil {
				panic(err)
			}
			err = scenario.policyWrapper.DeletePolicy(ctx, *policy.PolicyArn)
			if err != nil {
				panic(err)
			}
			log.Printf("Detached policy %v from role %v and deleted the policy.\n",
				*policy.PolicyName, *role.RoleName)
		}
		err = scenario.roleWrapper.DeleteRole(ctx, *role.RoleName)
		if err != nil {
			panic(err)
		}
		log.Printf("Deleted role %v.\n", *role.RoleName)

		userPols, err := scenario.userWrapper.ListUserPolicies(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		for _, userPol := range userPols {
			err = scenario.userWrapper.DeleteUserPolicy(ctx, *user.UserName, userPol)
			if err != nil {
				panic(err)
			}
			log.Printf("Deleted policy %v from user %v.\n", userPol, *user.UserName)
		}
		keys, err := scenario.userWrapper.ListAccessKeys(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		for _, key := range keys {
			err = scenario.userWrapper.DeleteAccessKey(ctx, *user.UserName, *key.AccessKeyId)
			if err != nil {
				panic(err)
			}
			log.Printf("Deleted access key %v from user %v.\n", *key.AccessKeyId, *user.UserName)
		}
		err = scenario.userWrapper.DeleteUser(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		log.Printf("Deleted user %v.\n", *user.UserName)
		log.Println(strings.Repeat("-", 88))
	}

}

// IScenarioHelper abstracts input and wait functions from a scenario so that they
// can be mocked for unit testing.
type IScenarioHelper interface {
	GetName() string
	Pause(secs int)
}

const rMax = 100000

type ScenarioHelper struct {
	Prefix string
	Random *rand.Rand
}

// GetName returns a unique name formed of a prefix and a random number.
func (helper *ScenarioHelper) GetName() string {
	return fmt.Sprintf("%v%v", helper.Prefix, helper.Random.Intn(rMax))
}

// Pause waits for the specified number of seconds.
func (helper ScenarioHelper) Pause(secs int) {
	time.Sleep(time.Duration(secs) * time.Second)
}
```
Defina una estructura que incluya las acciones de la cuenta.  

```
import (
	"context"
	"log"

	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// AccountWrapper encapsulates AWS Identity and Access Management (IAM) account actions
// used in the examples.
// It contains an IAM service client that is used to perform account actions.
type AccountWrapper struct {
	IamClient *iam.Client
}



// GetAccountPasswordPolicy gets the account password policy for the current account.
// If no policy has been set, a NoSuchEntityException is error is returned.
func (wrapper AccountWrapper) GetAccountPasswordPolicy(ctx context.Context) (*types.PasswordPolicy, error) {
	var pwPolicy *types.PasswordPolicy
	result, err := wrapper.IamClient.GetAccountPasswordPolicy(ctx,
		&iam.GetAccountPasswordPolicyInput{})
	if err != nil {
		log.Printf("Couldn't get account password policy. Here's why: %v\n", err)
	} else {
		pwPolicy = result.PasswordPolicy
	}
	return pwPolicy, err
}



// ListSAMLProviders gets the SAML providers for the account.
func (wrapper AccountWrapper) ListSAMLProviders(ctx context.Context) ([]types.SAMLProviderListEntry, error) {
	var providers []types.SAMLProviderListEntry
	result, err := wrapper.IamClient.ListSAMLProviders(ctx, &iam.ListSAMLProvidersInput{})
	if err != nil {
		log.Printf("Couldn't list SAML providers. Here's why: %v\n", err)
	} else {
		providers = result.SAMLProviderList
	}
	return providers, err
}
```
Defina una estructura que incluya las acciones de la política.  

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// PolicyWrapper encapsulates AWS Identity and Access Management (IAM) policy actions
// used in the examples.
// It contains an IAM service client that is used to perform policy actions.
type PolicyWrapper struct {
	IamClient *iam.Client
}



// ListPolicies gets up to maxPolicies policies.
func (wrapper PolicyWrapper) ListPolicies(ctx context.Context, maxPolicies int32) ([]types.Policy, error) {
	var policies []types.Policy
	result, err := wrapper.IamClient.ListPolicies(ctx, &iam.ListPoliciesInput{
		MaxItems: aws.Int32(maxPolicies),
	})
	if err != nil {
		log.Printf("Couldn't list policies. Here's why: %v\n", err)
	} else {
		policies = result.Policies
	}
	return policies, err
}



// PolicyDocument defines a policy document as a Go struct that can be serialized
// to JSON.
type PolicyDocument struct {
	Version   string
	Statement []PolicyStatement
}

// PolicyStatement defines a statement in a policy document.
type PolicyStatement struct {
	Effect    string
	Action    []string
	Principal map[string]string `json:",omitempty"`
	Resource  *string           `json:",omitempty"`
}

// CreatePolicy creates a policy that grants a list of actions to the specified resource.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper PolicyWrapper) CreatePolicy(ctx context.Context, policyName string, actions []string,
	resourceArn string) (*types.Policy, error) {
	var policy *types.Policy
	policyDoc := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:   "Allow",
			Action:   actions,
			Resource: aws.String(resourceArn),
		}},
	}
	policyBytes, err := json.Marshal(policyDoc)
	if err != nil {
		log.Printf("Couldn't create policy document for %v. Here's why: %v\n", resourceArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreatePolicy(ctx, &iam.CreatePolicyInput{
		PolicyDocument: aws.String(string(policyBytes)),
		PolicyName:     aws.String(policyName),
	})
	if err != nil {
		log.Printf("Couldn't create policy %v. Here's why: %v\n", policyName, err)
	} else {
		policy = result.Policy
	}
	return policy, err
}



// GetPolicy gets data about a policy.
func (wrapper PolicyWrapper) GetPolicy(ctx context.Context, policyArn string) (*types.Policy, error) {
	var policy *types.Policy
	result, err := wrapper.IamClient.GetPolicy(ctx, &iam.GetPolicyInput{
		PolicyArn: aws.String(policyArn),
	})
	if err != nil {
		log.Printf("Couldn't get policy %v. Here's why: %v\n", policyArn, err)
	} else {
		policy = result.Policy
	}
	return policy, err
}



// DeletePolicy deletes a policy.
func (wrapper PolicyWrapper) DeletePolicy(ctx context.Context, policyArn string) error {
	_, err := wrapper.IamClient.DeletePolicy(ctx, &iam.DeletePolicyInput{
		PolicyArn: aws.String(policyArn),
	})
	if err != nil {
		log.Printf("Couldn't delete policy %v. Here's why: %v\n", policyArn, err)
	}
	return err
}
```
Defina una estructura que incluya las acciones de rol.  

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// RoleWrapper encapsulates AWS Identity and Access Management (IAM) role actions
// used in the examples.
// It contains an IAM service client that is used to perform role actions.
type RoleWrapper struct {
	IamClient *iam.Client
}



// ListRoles gets up to maxRoles roles.
func (wrapper RoleWrapper) ListRoles(ctx context.Context, maxRoles int32) ([]types.Role, error) {
	var roles []types.Role
	result, err := wrapper.IamClient.ListRoles(ctx,
		&iam.ListRolesInput{MaxItems: aws.Int32(maxRoles)},
	)
	if err != nil {
		log.Printf("Couldn't list roles. Here's why: %v\n", err)
	} else {
		roles = result.Roles
	}
	return roles, err
}



// CreateRole creates a role that trusts a specified user. The trusted user can assume
// the role to acquire its permissions.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper RoleWrapper) CreateRole(ctx context.Context, roleName string, trustedUserArn string) (*types.Role, error) {
	var role *types.Role
	trustPolicy := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:    "Allow",
			Principal: map[string]string{"AWS": trustedUserArn},
			Action:    []string{"sts:AssumeRole"},
		}},
	}
	policyBytes, err := json.Marshal(trustPolicy)
	if err != nil {
		log.Printf("Couldn't create trust policy for %v. Here's why: %v\n", trustedUserArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreateRole(ctx, &iam.CreateRoleInput{
		AssumeRolePolicyDocument: aws.String(string(policyBytes)),
		RoleName:                 aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't create role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// GetRole gets data about a role.
func (wrapper RoleWrapper) GetRole(ctx context.Context, roleName string) (*types.Role, error) {
	var role *types.Role
	result, err := wrapper.IamClient.GetRole(ctx,
		&iam.GetRoleInput{RoleName: aws.String(roleName)})
	if err != nil {
		log.Printf("Couldn't get role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// CreateServiceLinkedRole creates a service-linked role that is owned by the specified service.
func (wrapper RoleWrapper) CreateServiceLinkedRole(ctx context.Context, serviceName string, description string) (
	*types.Role, error) {
	var role *types.Role
	result, err := wrapper.IamClient.CreateServiceLinkedRole(ctx, &iam.CreateServiceLinkedRoleInput{
		AWSServiceName: aws.String(serviceName),
		Description:    aws.String(description),
	})
	if err != nil {
		log.Printf("Couldn't create service-linked role %v. Here's why: %v\n", serviceName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// DeleteServiceLinkedRole deletes a service-linked role.
func (wrapper RoleWrapper) DeleteServiceLinkedRole(ctx context.Context, roleName string) error {
	_, err := wrapper.IamClient.DeleteServiceLinkedRole(ctx, &iam.DeleteServiceLinkedRoleInput{
		RoleName: aws.String(roleName)},
	)
	if err != nil {
		log.Printf("Couldn't delete service-linked role %v. Here's why: %v\n", roleName, err)
	}
	return err
}



// AttachRolePolicy attaches a policy to a role.
func (wrapper RoleWrapper) AttachRolePolicy(ctx context.Context, policyArn string, roleName string) error {
	_, err := wrapper.IamClient.AttachRolePolicy(ctx, &iam.AttachRolePolicyInput{
		PolicyArn: aws.String(policyArn),
		RoleName:  aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't attach policy %v to role %v. Here's why: %v\n", policyArn, roleName, err)
	}
	return err
}



// ListAttachedRolePolicies lists the policies that are attached to the specified role.
func (wrapper RoleWrapper) ListAttachedRolePolicies(ctx context.Context, roleName string) ([]types.AttachedPolicy, error) {
	var policies []types.AttachedPolicy
	result, err := wrapper.IamClient.ListAttachedRolePolicies(ctx, &iam.ListAttachedRolePoliciesInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't list attached policies for role %v. Here's why: %v\n", roleName, err)
	} else {
		policies = result.AttachedPolicies
	}
	return policies, err
}



// DetachRolePolicy detaches a policy from a role.
func (wrapper RoleWrapper) DetachRolePolicy(ctx context.Context, roleName string, policyArn string) error {
	_, err := wrapper.IamClient.DetachRolePolicy(ctx, &iam.DetachRolePolicyInput{
		PolicyArn: aws.String(policyArn),
		RoleName:  aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't detach policy from role %v. Here's why: %v\n", roleName, err)
	}
	return err
}



// ListRolePolicies lists the inline policies for a role.
func (wrapper RoleWrapper) ListRolePolicies(ctx context.Context, roleName string) ([]string, error) {
	var policies []string
	result, err := wrapper.IamClient.ListRolePolicies(ctx, &iam.ListRolePoliciesInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't list policies for role %v. Here's why: %v\n", roleName, err)
	} else {
		policies = result.PolicyNames
	}
	return policies, err
}



// DeleteRole deletes a role. All attached policies must be detached before a
// role can be deleted.
func (wrapper RoleWrapper) DeleteRole(ctx context.Context, roleName string) error {
	_, err := wrapper.IamClient.DeleteRole(ctx, &iam.DeleteRoleInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't delete role %v. Here's why: %v\n", roleName, err)
	}
	return err
}
```
Defina una estructura que incluya las acciones del usuario.  

```
import (
	"context"
	"encoding/json"
	"errors"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
	"github.com/aws/smithy-go"
)

// UserWrapper encapsulates user actions used in the examples.
// It contains an IAM service client that is used to perform user actions.
type UserWrapper struct {
	IamClient *iam.Client
}



// ListUsers gets up to maxUsers number of users.
func (wrapper UserWrapper) ListUsers(ctx context.Context, maxUsers int32) ([]types.User, error) {
	var users []types.User
	result, err := wrapper.IamClient.ListUsers(ctx, &iam.ListUsersInput{
		MaxItems: aws.Int32(maxUsers),
	})
	if err != nil {
		log.Printf("Couldn't list users. Here's why: %v\n", err)
	} else {
		users = result.Users
	}
	return users, err
}



// GetUser gets data about a user.
func (wrapper UserWrapper) GetUser(ctx context.Context, userName string) (*types.User, error) {
	var user *types.User
	result, err := wrapper.IamClient.GetUser(ctx, &iam.GetUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		var apiError smithy.APIError
		if errors.As(err, &apiError) {
			switch apiError.(type) {
			case *types.NoSuchEntityException:
				log.Printf("User %v does not exist.\n", userName)
				err = nil
			default:
				log.Printf("Couldn't get user %v. Here's why: %v\n", userName, err)
			}
		}
	} else {
		user = result.User
	}
	return user, err
}



// CreateUser creates a new user with the specified name.
func (wrapper UserWrapper) CreateUser(ctx context.Context, userName string) (*types.User, error) {
	var user *types.User
	result, err := wrapper.IamClient.CreateUser(ctx, &iam.CreateUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't create user %v. Here's why: %v\n", userName, err)
	} else {
		user = result.User
	}
	return user, err
}



// CreateUserPolicy adds an inline policy to a user. This example creates a policy that
// grants a list of actions on a specified role.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper UserWrapper) CreateUserPolicy(ctx context.Context, userName string, policyName string, actions []string,
	roleArn string) error {
	policyDoc := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:   "Allow",
			Action:   actions,
			Resource: aws.String(roleArn),
		}},
	}
	policyBytes, err := json.Marshal(policyDoc)
	if err != nil {
		log.Printf("Couldn't create policy document for %v. Here's why: %v\n", roleArn, err)
		return err
	}
	_, err = wrapper.IamClient.PutUserPolicy(ctx, &iam.PutUserPolicyInput{
		PolicyDocument: aws.String(string(policyBytes)),
		PolicyName:     aws.String(policyName),
		UserName:       aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't create policy for user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// ListUserPolicies lists the inline policies for the specified user.
func (wrapper UserWrapper) ListUserPolicies(ctx context.Context, userName string) ([]string, error) {
	var policies []string
	result, err := wrapper.IamClient.ListUserPolicies(ctx, &iam.ListUserPoliciesInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't list policies for user %v. Here's why: %v\n", userName, err)
	} else {
		policies = result.PolicyNames
	}
	return policies, err
}



// DeleteUserPolicy deletes an inline policy from a user.
func (wrapper UserWrapper) DeleteUserPolicy(ctx context.Context, userName string, policyName string) error {
	_, err := wrapper.IamClient.DeleteUserPolicy(ctx, &iam.DeleteUserPolicyInput{
		PolicyName: aws.String(policyName),
		UserName:   aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete policy from user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// DeleteUser deletes a user.
func (wrapper UserWrapper) DeleteUser(ctx context.Context, userName string) error {
	_, err := wrapper.IamClient.DeleteUser(ctx, &iam.DeleteUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// CreateAccessKeyPair creates an access key for a user. The returned access key contains
// the ID and secret credentials needed to use the key.
func (wrapper UserWrapper) CreateAccessKeyPair(ctx context.Context, userName string) (*types.AccessKey, error) {
	var key *types.AccessKey
	result, err := wrapper.IamClient.CreateAccessKey(ctx, &iam.CreateAccessKeyInput{
		UserName: aws.String(userName)})
	if err != nil {
		log.Printf("Couldn't create access key pair for user %v. Here's why: %v\n", userName, err)
	} else {
		key = result.AccessKey
	}
	return key, err
}



// DeleteAccessKey deletes an access key from a user.
func (wrapper UserWrapper) DeleteAccessKey(ctx context.Context, userName string, keyId string) error {
	_, err := wrapper.IamClient.DeleteAccessKey(ctx, &iam.DeleteAccessKeyInput{
		AccessKeyId: aws.String(keyId),
		UserName:    aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete access key %v. Here's why: %v\n", keyId, err)
	}
	return err
}



// ListAccessKeys lists the access keys for the specified user.
func (wrapper UserWrapper) ListAccessKeys(ctx context.Context, userName string) ([]types.AccessKeyMetadata, error) {
	var keys []types.AccessKeyMetadata
	result, err := wrapper.IamClient.ListAccessKeys(ctx, &iam.ListAccessKeysInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't list access keys for user %v. Here's why: %v\n", userName, err)
	} else {
		keys = result.AccessKeyMetadata
	}
	return keys, err
}
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *referencia de la API de AWS SDK para Go*.
  + [AttachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.AttachRolePolicy)
  + [CreateAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateAccessKey)
  + [CreatePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreatePolicy)
  + [CreateRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateRole)
  + [CreateUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateUser)
  + [DeleteAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteAccessKey)
  + [DeletePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeletePolicy)
  + [DeleteRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteRole)
  + [DeleteUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUser)
  + [DeleteUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUserPolicy)
  + [DetachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DetachRolePolicy)
  + [PutUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.PutUserPolicy)

------
#### [ Java ]

**SDK para Java 2.x**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/iam#code-examples). 
Cree funciones que encapsulen las acciones del usuario de IAM.  

```
/*
  To run this Java V2 code example, set up your development environment, including your credentials.

  For information, see this documentation topic:

  https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html

  This example performs these operations:

  1. Creates a user that has no permissions.
  2. Creates a role and policy that grants Amazon S3 permissions.
  3. Creates a role.
  4. Grants the user permissions.
  5. Gets temporary credentials by assuming the role.  Creates an Amazon S3 Service client object with the temporary credentials.
  6. Deletes the resources.
 */

public class IAMScenario {
    public static final String DASHES = new String(new char[80]).replace("\0", "-");
    public static final String PolicyDocument = "{" +
            "  \"Version\": \"2012-10-17\"," +
            "  \"Statement\": [" +
            "    {" +
            "        \"Effect\": \"Allow\"," +
            "        \"Action\": [" +
            "            \"s3:*\"" +
            "       ]," +
            "       \"Resource\": \"*\"" +
            "    }" +
            "   ]" +
            "}";

    public static String userArn;

    public static void main(String[] args) throws Exception {

        final String usage = """

                Usage:
                    <username> <policyName> <roleName> <roleSessionName> <bucketName>\s

                Where:
                    username - The name of the IAM user to create.\s
                    policyName - The name of the policy to create.\s
                    roleName - The name of the role to create.\s
                    roleSessionName - The name of the session required for the assumeRole operation.\s
                    bucketName - The name of the Amazon S3 bucket from which objects are read.\s
                """;

        if (args.length != 5) {
            System.out.println(usage);
            System.exit(1);
        }

        String userName = args[0];
        String policyName = args[1];
        String roleName = args[2];
        String roleSessionName = args[3];
        String bucketName = args[4];

        Region region = Region.AWS_GLOBAL;
        IamClient iam = IamClient.builder()
                .region(region)
                .build();

        System.out.println(DASHES);
        System.out.println("Welcome to the AWS IAM example scenario.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println(" 1. Create the IAM user.");
        User createUser = createIAMUser(iam, userName);

        System.out.println(DASHES);
        userArn = createUser.arn();

        AccessKey myKey = createIAMAccessKey(iam, userName);
        String accessKey = myKey.accessKeyId();
        String secretKey = myKey.secretAccessKey();
        String assumeRolePolicyDocument = "{" +
                "\"Version\": \"2012-10-17\"," +
                "\"Statement\": [{" +
                "\"Effect\": \"Allow\"," +
                "\"Principal\": {" +
                "	\"AWS\": \"" + userArn + "\"" +
                "}," +
                "\"Action\": \"sts:AssumeRole\"" +
                "}]" +
                "}";

        System.out.println(assumeRolePolicyDocument);
        System.out.println(userName + " was successfully created.");
        System.out.println(DASHES);
        System.out.println("2. Creates a policy.");
        String polArn = createIAMPolicy(iam, policyName);
        System.out.println("The policy " + polArn + " was successfully created.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("3. Creates a role.");
        TimeUnit.SECONDS.sleep(30);
        String roleArn = createIAMRole(iam, roleName, assumeRolePolicyDocument);
        System.out.println(roleArn + " was successfully created.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("4. Grants the user permissions.");
        attachIAMRolePolicy(iam, roleName, polArn);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("*** Wait for 30 secs so the resource is available");
        TimeUnit.SECONDS.sleep(30);
        System.out.println("5. Gets temporary credentials by assuming the role.");
        System.out.println("Perform an Amazon S3 Service operation using the temporary credentials.");
        assumeRole(roleArn, roleSessionName, bucketName, accessKey, secretKey);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("6 Getting ready to delete the AWS resources");
        deleteKey(iam, userName, accessKey);
        deleteRole(iam, roleName, polArn);
        deleteIAMUser(iam, userName);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("This IAM Scenario has successfully completed");
        System.out.println(DASHES);
    }

    public static AccessKey createIAMAccessKey(IamClient iam, String user) {
        try {
            CreateAccessKeyRequest request = CreateAccessKeyRequest.builder()
                    .userName(user)
                    .build();

            CreateAccessKeyResponse response = iam.createAccessKey(request);
            return response.accessKey();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }

    public static User createIAMUser(IamClient iam, String username) {
        try {
            // Create an IamWaiter object
            IamWaiter iamWaiter = iam.waiter();
            CreateUserRequest request = CreateUserRequest.builder()
                    .userName(username)
                    .build();

            // Wait until the user is created.
            CreateUserResponse response = iam.createUser(request);
            GetUserRequest userRequest = GetUserRequest.builder()
                    .userName(response.user().userName())
                    .build();

            WaiterResponse<GetUserResponse> waitUntilUserExists = iamWaiter.waitUntilUserExists(userRequest);
            waitUntilUserExists.matched().response().ifPresent(System.out::println);
            return response.user();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }

    public static String createIAMRole(IamClient iam, String rolename, String json) {

        try {
            CreateRoleRequest request = CreateRoleRequest.builder()
                    .roleName(rolename)
                    .assumeRolePolicyDocument(json)
                    .description("Created using the AWS SDK for Java")
                    .build();

            CreateRoleResponse response = iam.createRole(request);
            System.out.println("The ARN of the role is " + response.role().arn());
            return response.role().arn();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static String createIAMPolicy(IamClient iam, String policyName) {
        try {
            // Create an IamWaiter object.
            IamWaiter iamWaiter = iam.waiter();
            CreatePolicyRequest request = CreatePolicyRequest.builder()
                    .policyName(policyName)
                    .policyDocument(PolicyDocument).build();

            CreatePolicyResponse response = iam.createPolicy(request);
            GetPolicyRequest polRequest = GetPolicyRequest.builder()
                    .policyArn(response.policy().arn())
                    .build();

            WaiterResponse<GetPolicyResponse> waitUntilPolicyExists = iamWaiter.waitUntilPolicyExists(polRequest);
            waitUntilPolicyExists.matched().response().ifPresent(System.out::println);
            return response.policy().arn();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static void attachIAMRolePolicy(IamClient iam, String roleName, String policyArn) {
        try {
            ListAttachedRolePoliciesRequest request = ListAttachedRolePoliciesRequest.builder()
                    .roleName(roleName)
                    .build();

            ListAttachedRolePoliciesResponse response = iam.listAttachedRolePolicies(request);
            List<AttachedPolicy> attachedPolicies = response.attachedPolicies();
            String polArn;
            for (AttachedPolicy policy : attachedPolicies) {
                polArn = policy.policyArn();
                if (polArn.compareTo(policyArn) == 0) {
                    System.out.println(roleName + " policy is already attached to this role.");
                    return;
                }
            }

            AttachRolePolicyRequest attachRequest = AttachRolePolicyRequest.builder()
                    .roleName(roleName)
                    .policyArn(policyArn)
                    .build();

            iam.attachRolePolicy(attachRequest);
            System.out.println("Successfully attached policy " + policyArn + " to role " + roleName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    // Invoke an Amazon S3 operation using the Assumed Role.
    public static void assumeRole(String roleArn, String roleSessionName, String bucketName, String keyVal,
            String keySecret) {

        // Use the creds of the new IAM user that was created in this code example.
        AwsBasicCredentials credentials = AwsBasicCredentials.create(keyVal, keySecret);
        StsClient stsClient = StsClient.builder()
                .region(Region.US_EAST_1)
                .credentialsProvider(StaticCredentialsProvider.create(credentials))
                .build();

        try {
            AssumeRoleRequest roleRequest = AssumeRoleRequest.builder()
                    .roleArn(roleArn)
                    .roleSessionName(roleSessionName)
                    .build();

            AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest);
            Credentials myCreds = roleResponse.credentials();
            String key = myCreds.accessKeyId();
            String secKey = myCreds.secretAccessKey();
            String secToken = myCreds.sessionToken();

            // List all objects in an Amazon S3 bucket using the temp creds retrieved by
            // invoking assumeRole.
            Region region = Region.US_EAST_1;
            S3Client s3 = S3Client.builder()
                    .credentialsProvider(
                            StaticCredentialsProvider.create(AwsSessionCredentials.create(key, secKey, secToken)))
                    .region(region)
                    .build();

            System.out.println("Created a S3Client using temp credentials.");
            System.out.println("Listing objects in " + bucketName);
            ListObjectsRequest listObjects = ListObjectsRequest.builder()
                    .bucket(bucketName)
                    .build();

            ListObjectsResponse res = s3.listObjects(listObjects);
            List<S3Object> objects = res.contents();
            for (S3Object myValue : objects) {
                System.out.println("The name of the key is " + myValue.key());
                System.out.println("The owner is " + myValue.owner());
            }

        } catch (StsException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }
    }

    public static void deleteRole(IamClient iam, String roleName, String polArn) {

        try {
            // First the policy needs to be detached.
            DetachRolePolicyRequest rolePolicyRequest = DetachRolePolicyRequest.builder()
                    .policyArn(polArn)
                    .roleName(roleName)
                    .build();

            iam.detachRolePolicy(rolePolicyRequest);

            // Delete the policy.
            DeletePolicyRequest request = DeletePolicyRequest.builder()
                    .policyArn(polArn)
                    .build();

            iam.deletePolicy(request);
            System.out.println("*** Successfully deleted " + polArn);

            // Delete the role.
            DeleteRoleRequest roleRequest = DeleteRoleRequest.builder()
                    .roleName(roleName)
                    .build();

            iam.deleteRole(roleRequest);
            System.out.println("*** Successfully deleted " + roleName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void deleteKey(IamClient iam, String username, String accessKey) {
        try {
            DeleteAccessKeyRequest request = DeleteAccessKeyRequest.builder()
                    .accessKeyId(accessKey)
                    .userName(username)
                    .build();

            iam.deleteAccessKey(request);
            System.out.println("Successfully deleted access key " + accessKey +
                    " from user " + username);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void deleteIAMUser(IamClient iam, String userName) {
        try {
            DeleteUserRequest request = DeleteUserRequest.builder()
                    .userName(userName)
                    .build();

            iam.deleteUser(request);
            System.out.println("*** Successfully deleted " + userName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
}
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *referencia de la API de AWS SDK for Java 2.x*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/PutUserPolicy)

------
#### [ JavaScript ]

**SDK para JavaScript (v3)**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/iam#code-examples). 
Cree un usuario de IAM y un rol que conceda permiso para enumerar los buckets de Amazon S3. El usuario solo tiene derechos para asumir el rol. Después de asumir el rol, use las credenciales temporales para enumerar los buckets de la cuenta.  

```
import {
  CreateUserCommand,
  GetUserCommand,
  CreateAccessKeyCommand,
  CreatePolicyCommand,
  CreateRoleCommand,
  AttachRolePolicyCommand,
  DeleteAccessKeyCommand,
  DeleteUserCommand,
  DeleteRoleCommand,
  DeletePolicyCommand,
  DetachRolePolicyCommand,
  IAMClient,
} from "@aws-sdk/client-iam";
import { ListBucketsCommand, S3Client } from "@aws-sdk/client-s3";
import { AssumeRoleCommand, STSClient } from "@aws-sdk/client-sts";
import { retry } from "@aws-doc-sdk-examples/lib/utils/util-timers.js";
import { ScenarioInput } from "@aws-doc-sdk-examples/lib/scenario/index.js";

// Set the parameters.
const iamClient = new IAMClient({});
const userName = "iam_basic_test_username";
const policyName = "iam_basic_test_policy";
const roleName = "iam_basic_test_role";

/**
 * Create a new IAM user. If the user already exists, give
 * the option to delete and re-create it.
 * @param {string} name
 */
export const createUser = async (name, confirmAll = false) => {
  try {
    const { User } = await iamClient.send(
      new GetUserCommand({ UserName: name }),
    );
    const input = new ScenarioInput(
      "deleteUser",
      "Do you want to delete and remake this user?",
      { type: "confirm" },
    );
    const deleteUser = await input.handle({}, { confirmAll });
    // If the user exists, and you want to delete it, delete the user
    // and then create it again.
    if (deleteUser) {
      await iamClient.send(new DeleteUserCommand({ UserName: User.UserName }));
      await iamClient.send(new CreateUserCommand({ UserName: name }));
    } else {
      console.warn(
        `${name} already exists. The scenario may not work as expected.`,
      );
      return User;
    }
  } catch (caught) {
    // If there is no user by that name, create one.
    if (caught instanceof Error && caught.name === "NoSuchEntityException") {
      const { User } = await iamClient.send(
        new CreateUserCommand({ UserName: name }),
      );
      return User;
    }
    throw caught;
  }
};

export const main = async (confirmAll = false) => {
  // Create a user. The user has no permissions by default.
  const User = await createUser(userName, confirmAll);

  if (!User) {
    throw new Error("User not created");
  }

  // Create an access key. This key is used to authenticate the new user to
  // Amazon Simple Storage Service (Amazon S3) and AWS Security Token Service (AWS STS).
  // It's not best practice to use access keys. For more information, see https://aws.amazon.com/iam/resources/best-practices/.
  const createAccessKeyResponse = await iamClient.send(
    new CreateAccessKeyCommand({ UserName: userName }),
  );

  if (
    !createAccessKeyResponse.AccessKey?.AccessKeyId ||
    !createAccessKeyResponse.AccessKey?.SecretAccessKey
  ) {
    throw new Error("Access key not created");
  }

  const {
    AccessKey: { AccessKeyId, SecretAccessKey },
  } = createAccessKeyResponse;

  let s3Client = new S3Client({
    credentials: {
      accessKeyId: AccessKeyId,
      secretAccessKey: SecretAccessKey,
    },
  });

  // Retry the list buckets operation until it succeeds. InvalidAccessKeyId is
  // thrown while the user and access keys are still stabilizing.
  await retry({ intervalInMs: 1000, maxRetries: 300 }, async () => {
    try {
      return await listBuckets(s3Client);
    } catch (err) {
      if (err instanceof Error && err.name === "InvalidAccessKeyId") {
        throw err;
      }
    }
  });

  // Retry the create role operation until it succeeds. A MalformedPolicyDocument error
  // is thrown while the user and access keys are still stabilizing.
  const { Role } = await retry(
    {
      intervalInMs: 2000,
      maxRetries: 60,
    },
    () =>
      iamClient.send(
        new CreateRoleCommand({
          AssumeRolePolicyDocument: JSON.stringify({
            Version: "2012-10-17",
            Statement: [
              {
                Effect: "Allow",
                Principal: {
                  // Allow the previously created user to assume this role.
                  AWS: User.Arn,
                },
                Action: "sts:AssumeRole",
              },
            ],
          }),
          RoleName: roleName,
        }),
      ),
  );

  if (!Role) {
    throw new Error("Role not created");
  }

  // Create a policy that allows the user to list S3 buckets.
  const { Policy: listBucketPolicy } = await iamClient.send(
    new CreatePolicyCommand({
      PolicyDocument: JSON.stringify({
        Version: "2012-10-17",
        Statement: [
          {
            Effect: "Allow",
            Action: ["s3:ListAllMyBuckets"],
            Resource: "*",
          },
        ],
      }),
      PolicyName: policyName,
    }),
  );

  if (!listBucketPolicy) {
    throw new Error("Policy not created");
  }

  // Attach the policy granting the 's3:ListAllMyBuckets' action to the role.
  await iamClient.send(
    new AttachRolePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
      RoleName: Role.RoleName,
    }),
  );

  // Assume the role.
  const stsClient = new STSClient({
    credentials: {
      accessKeyId: AccessKeyId,
      secretAccessKey: SecretAccessKey,
    },
  });

  // Retry the assume role operation until it succeeds.
  const { Credentials } = await retry(
    { intervalInMs: 2000, maxRetries: 60 },
    () =>
      stsClient.send(
        new AssumeRoleCommand({
          RoleArn: Role.Arn,
          RoleSessionName: `iamBasicScenarioSession-${Math.floor(
            Math.random() * 1000000,
          )}`,
          DurationSeconds: 900,
        }),
      ),
  );

  if (!Credentials?.AccessKeyId || !Credentials?.SecretAccessKey) {
    throw new Error("Credentials not created");
  }

  s3Client = new S3Client({
    credentials: {
      accessKeyId: Credentials.AccessKeyId,
      secretAccessKey: Credentials.SecretAccessKey,
      sessionToken: Credentials.SessionToken,
    },
  });

  // List the S3 buckets again.
  // Retry the list buckets operation until it succeeds. AccessDenied might
  // be thrown while the role policy is still stabilizing.
  await retry({ intervalInMs: 2000, maxRetries: 120 }, () =>
    listBuckets(s3Client),
  );

  // Clean up.
  await iamClient.send(
    new DetachRolePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
      RoleName: Role.RoleName,
    }),
  );

  await iamClient.send(
    new DeletePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
    }),
  );

  await iamClient.send(
    new DeleteRoleCommand({
      RoleName: Role.RoleName,
    }),
  );

  await iamClient.send(
    new DeleteAccessKeyCommand({
      UserName: userName,
      AccessKeyId,
    }),
  );

  await iamClient.send(
    new DeleteUserCommand({
      UserName: userName,
    }),
  );
};

/**
 *
 * @param {S3Client} s3Client
 */
const listBuckets = async (s3Client) => {
  const { Buckets } = await s3Client.send(new ListBucketsCommand({}));

  if (!Buckets) {
    throw new Error("Buckets not listed");
  }

  console.log(Buckets.map((bucket) => bucket.Name).join("\n"));
};
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *referencia de la API de AWS SDK para JavaScript*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/AttachRolePolicyCommand)
  + [CreateAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateAccessKeyCommand)
  + [CreatePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreatePolicyCommand)
  + [CreateRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateRoleCommand)
  + [CreateUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateUserCommand)
  + [DeleteAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteAccessKeyCommand)
  + [DeletePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeletePolicyCommand)
  + [DeleteRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteRoleCommand)
  + [DeleteUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserCommand)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserPolicyCommand)
  + [DetachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DetachRolePolicyCommand)
  + [PutUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/PutUserPolicyCommand)

------
#### [ Kotlin ]

**SDK para Kotlin**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/iam#code-examples). 
Cree funciones que encapsulen las acciones del usuario de IAM.  

```
suspend fun main(args: Array<String>) {
    val usage = """
    Usage:
        <username> <policyName> <roleName> <roleSessionName> <fileLocation> <bucketName> 

    Where:
        username - The name of the IAM user to create. 
        policyName - The name of the policy to create. 
        roleName - The name of the role to create. 
        roleSessionName - The name of the session required for the assumeRole operation. 
        fileLocation - The file location to the JSON required to create the role (see Readme). 
        bucketName - The name of the Amazon S3 bucket from which objects are read. 
    """

    if (args.size != 6) {
        println(usage)
        exitProcess(1)
    }

    val userName = args[0]
    val policyName = args[1]
    val roleName = args[2]
    val roleSessionName = args[3]
    val fileLocation = args[4]
    val bucketName = args[5]

    createUser(userName)
    println("$userName was successfully created.")

    val polArn = createPolicy(policyName)
    println("The policy $polArn was successfully created.")

    val roleArn = createRole(roleName, fileLocation)
    println("$roleArn was successfully created.")
    attachRolePolicy(roleName, polArn)

    println("*** Wait for 1 MIN so the resource is available.")
    delay(60000)
    assumeGivenRole(roleArn, roleSessionName, bucketName)

    println("*** Getting ready to delete the AWS resources.")
    deleteRole(roleName, polArn)
    deleteUser(userName)
    println("This IAM Scenario has successfully completed.")
}

suspend fun createUser(usernameVal: String?): String? {
    val request =
        CreateUserRequest {
            userName = usernameVal
        }

    IamClient { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createUser(request)
        return response.user?.userName
    }
}

suspend fun createPolicy(policyNameVal: String?): String {
    val policyDocumentValue = """
    {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "s3:*"
                ],
                "Resource": "*"
            }
        ]
    }
    """.trimIndent()

    val request =
        CreatePolicyRequest {
            policyName = policyNameVal
            policyDocument = policyDocumentValue
        }

    IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createPolicy(request)
        return response.policy?.arn.toString()
    }
}

suspend fun createRole(
    rolenameVal: String?,
    fileLocation: String?,
): String? {
    val jsonObject = fileLocation?.let { readJsonSimpleDemo(it) } as JSONObject

    val request =
        CreateRoleRequest {
            roleName = rolenameVal
            assumeRolePolicyDocument = jsonObject.toJSONString()
            description = "Created using the AWS SDK for Kotlin"
        }

    IamClient { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createRole(request)
        return response.role?.arn
    }
}

suspend fun attachRolePolicy(
    roleNameVal: String,
    policyArnVal: String,
) {
    val request =
        ListAttachedRolePoliciesRequest {
            roleName = roleNameVal
        }

    IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.listAttachedRolePolicies(request)
        val attachedPolicies = response.attachedPolicies

        // Ensure that the policy is not attached to this role.
        val checkStatus: Int
        if (attachedPolicies != null) {
            checkStatus = checkMyList(attachedPolicies, policyArnVal)
            if (checkStatus == -1) {
                return
            }
        }

        val policyRequest =
            AttachRolePolicyRequest {
                roleName = roleNameVal
                policyArn = policyArnVal
            }
        iamClient.attachRolePolicy(policyRequest)
        println("Successfully attached policy $policyArnVal to role $roleNameVal")
    }
}

fun checkMyList(
    attachedPolicies: List<AttachedPolicy>,
    policyArnVal: String,
): Int {
    for (policy in attachedPolicies) {
        val polArn = policy.policyArn.toString()

        if (polArn.compareTo(policyArnVal) == 0) {
            println("The policy is already attached to this role.")
            return -1
        }
    }
    return 0
}

suspend fun assumeGivenRole(
    roleArnVal: String?,
    roleSessionNameVal: String?,
    bucketName: String,
) {
    val stsClient = StsClient.fromEnvironment { region = "us-east-1" }
    val roleRequest =
        AssumeRoleRequest {
            roleArn = roleArnVal
            roleSessionName = roleSessionNameVal
        }

    val roleResponse = stsClient.assumeRole(roleRequest)
    val myCreds = roleResponse.credentials
    val key = myCreds?.accessKeyId
    val secKey = myCreds?.secretAccessKey
    val secToken = myCreds?.sessionToken

    val staticCredentials = StaticCredentialsProvider {
        accessKeyId = key
        secretAccessKey = secKey
        sessionToken = secToken
    }

    // List all objects in an Amazon S3 bucket using the temp creds.
    val s3 = S3Client.fromEnvironment {
        region = "us-east-1"
        credentialsProvider = staticCredentials
    }

    println("Created a S3Client using temp credentials.")
    println("Listing objects in $bucketName")

    val listObjects =
        ListObjectsRequest {
            bucket = bucketName
        }

    val response = s3.listObjects(listObjects)
    response.contents?.forEach { myObject ->
        println("The name of the key is ${myObject.key}")
        println("The owner is ${myObject.owner}")
    }
}

suspend fun deleteRole(
    roleNameVal: String,
    polArn: String,
) {
    val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" }

    // First the policy needs to be detached.
    val rolePolicyRequest =
        DetachRolePolicyRequest {
            policyArn = polArn
            roleName = roleNameVal
        }

    iam.detachRolePolicy(rolePolicyRequest)

    // Delete the policy.
    val request =
        DeletePolicyRequest {
            policyArn = polArn
        }

    iam.deletePolicy(request)
    println("*** Successfully deleted $polArn")

    // Delete the role.
    val roleRequest =
        DeleteRoleRequest {
            roleName = roleNameVal
        }

    iam.deleteRole(roleRequest)
    println("*** Successfully deleted $roleNameVal")
}

suspend fun deleteUser(userNameVal: String) {
    val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" }
    val request =
        DeleteUserRequest {
            userName = userNameVal
        }

    iam.deleteUser(request)
    println("*** Successfully deleted $userNameVal")
}

@Throws(java.lang.Exception::class)
fun readJsonSimpleDemo(filename: String): Any? {
    val reader = FileReader(filename)
    val jsonParser = JSONParser()
    return jsonParser.parse(reader)
}
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para Kotlin*.
  + [AttachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreatePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeletePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DetachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [PutUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)

------
#### [ PHP ]

**SDK para PHP**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/iam#code-examples). 

```
namespace Iam\Basics;

require 'vendor/autoload.php';

use Aws\Credentials\Credentials;
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
use Iam\IAMService;

echo("\n");
echo("--------------------------------------\n");
print("Welcome to the IAM getting started demo using PHP!\n");
echo("--------------------------------------\n");

$uuid = uniqid();
$service = new IAMService();

$user = $service->createUser("iam_demo_user_$uuid");
echo "Created user with the arn: {$user['Arn']}\n";

$key = $service->createAccessKey($user['UserName']);
$assumeRolePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{$user['Arn']}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";

$listAllBucketsPolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]
}";
$listAllBucketsPolicy = $service->createPolicy("iam_demo_policy_$uuid", $listAllBucketsPolicyDocument);
echo "Created policy: {$listAllBucketsPolicy['PolicyName']}\n";

$service->attachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);

$inlinePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"{$assumeRoleRole['Arn']}\"}]
}";
$inlinePolicy = $service->createUserPolicy("iam_demo_inline_policy_$uuid", $inlinePolicyDocument, $user['UserName']);
//First, fail to list the buckets with the user
$credentials = new Credentials($key['AccessKeyId'], $key['SecretAccessKey']);
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
try {
    $s3Client->listBuckets([
    ]);
    echo "this should not run";
} catch (S3Exception $exception) {
    echo "successfully failed!\n";
}

$stsClient = new StsClient(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
sleep(10);
$assumedRole = $stsClient->assumeRole([
    'RoleArn' => $assumeRoleRole['Arn'],
    'RoleSessionName' => "DemoAssumeRoleSession_$uuid",
]);
$assumedCredentials = [
    'key' => $assumedRole['Credentials']['AccessKeyId'],
    'secret' => $assumedRole['Credentials']['SecretAccessKey'],
    'token' => $assumedRole['Credentials']['SessionToken'],
];
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $assumedCredentials]);
try {
    $s3Client->listBuckets([]);
    echo "this should now run!\n";
} catch (S3Exception $exception) {
    echo "this should now not fail\n";
}

$service->detachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);
$deletePolicy = $service->deletePolicy($listAllBucketsPolicy['Arn']);
echo "Delete policy: {$listAllBucketsPolicy['PolicyName']}\n";
$deletedRole = $service->deleteRole($assumeRoleRole['Arn']);
echo "Deleted role: {$assumeRoleRole['RoleName']}\n";
$deletedKey = $service->deleteAccessKey($key['AccessKeyId'], $user['UserName']);
$deletedUser = $service->deleteUser($user['UserName']);
echo "Delete user: {$user['UserName']}\n";
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *referencia de la API de AWS SDK para PHP*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Python ]

**SDK para Python (Boto3)**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/iam#code-examples). 
Cree un usuario de IAM y un rol que conceda permiso para enumerar los buckets de Amazon S3. El usuario solo tiene derechos para asumir el rol. Después de asumir el rol, use las credenciales temporales para enumerar los buckets de la cuenta.  

```
import json
import sys
import time
from uuid import uuid4

import boto3
from botocore.exceptions import ClientError


def progress_bar(seconds):
    """Shows a simple progress bar in the command window."""
    for _ in range(seconds):
        time.sleep(1)
        print(".", end="")
        sys.stdout.flush()
    print()


def setup(iam_resource):
    """
    Creates a new user with no permissions.
    Creates an access key pair for the user.
    Creates a role with a policy that lets the user assume the role.
    Creates a policy that allows listing Amazon S3 buckets.
    Attaches the policy to the role.
    Creates an inline policy for the user that lets the user assume the role.

    :param iam_resource: A Boto3 AWS Identity and Access Management (IAM) resource
                         that has permissions to create users, roles, and policies
                         in the account.
    :return: The newly created user, user key, and role.
    """
    try:
        user = iam_resource.create_user(UserName=f"demo-user-{uuid4()}")
        print(f"Created user {user.name}.")
    except ClientError as error:
        print(
            f"Couldn't create a user for the demo. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        user_key = user.create_access_key_pair()
        print(f"Created access key pair for user.")
    except ClientError as error:
        print(
            f"Couldn't create access keys for user {user.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    print(f"Wait for user to be ready.", end="")
    progress_bar(10)

    try:
        role = iam_resource.create_role(
            RoleName=f"demo-role-{uuid4()}",
            AssumeRolePolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {"AWS": user.arn},
                            "Action": "sts:AssumeRole",
                        }
                    ],
                }
            ),
        )
        print(f"Created role {role.name}.")
    except ClientError as error:
        print(
            f"Couldn't create a role for the demo. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        policy = iam_resource.create_policy(
            PolicyName=f"demo-policy-{uuid4()}",
            PolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "s3:ListAllMyBuckets",
                            "Resource": "arn:aws:s3:::*",
                        }
                    ],
                }
            ),
        )
        role.attach_policy(PolicyArn=policy.arn)
        print(f"Created policy {policy.policy_name} and attached it to the role.")
    except ClientError as error:
        print(
            f"Couldn't create a policy and attach it to role {role.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        user.create_policy(
            PolicyName=f"demo-user-policy-{uuid4()}",
            PolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "sts:AssumeRole",
                            "Resource": role.arn,
                        }
                    ],
                }
            ),
        )
        print(
            f"Created an inline policy for {user.name} that lets the user assume "
            f"the role."
        )
    except ClientError as error:
        print(
            f"Couldn't create an inline policy for user {user.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    print("Give AWS time to propagate these new resources and connections.", end="")
    progress_bar(10)

    return user, user_key, role


def show_access_denied_without_role(user_key):
    """
    Shows that listing buckets without first assuming the role is not allowed.

    :param user_key: The key of the user created during setup. This user does not
                     have permission to list buckets in the account.
    """
    print(f"Try to list buckets without first assuming the role.")
    s3_denied_resource = boto3.resource(
        "s3", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret
    )
    try:
        for bucket in s3_denied_resource.buckets.all():
            print(bucket.name)
        raise RuntimeError("Expected to get AccessDenied error when listing buckets!")
    except ClientError as error:
        if error.response["Error"]["Code"] == "AccessDenied":
            print("Attempt to list buckets with no permissions: AccessDenied.")
        else:
            raise


def list_buckets_from_assumed_role(user_key, assume_role_arn, session_name):
    """
    Assumes a role that grants permission to list the Amazon S3 buckets in the account.
    Uses the temporary credentials from the role to list the buckets that are owned
    by the assumed role's account.

    :param user_key: The access key of a user that has permission to assume the role.
    :param assume_role_arn: The Amazon Resource Name (ARN) of the role that
                            grants access to list the other account's buckets.
    :param session_name: The name of the STS session.
    """
    sts_client = boto3.client(
        "sts", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret
    )
    try:
        response = sts_client.assume_role(
            RoleArn=assume_role_arn, RoleSessionName=session_name
        )
        temp_credentials = response["Credentials"]
        print(f"Assumed role {assume_role_arn} and got temporary credentials.")
    except ClientError as error:
        print(
            f"Couldn't assume role {assume_role_arn}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    # Create an S3 resource that can access the account with the temporary credentials.
    s3_resource = boto3.resource(
        "s3",
        aws_access_key_id=temp_credentials["AccessKeyId"],
        aws_secret_access_key=temp_credentials["SecretAccessKey"],
        aws_session_token=temp_credentials["SessionToken"],
    )
    print(f"Listing buckets for the assumed role's account:")
    try:
        for bucket in s3_resource.buckets.all():
            print(bucket.name)
    except ClientError as error:
        print(
            f"Couldn't list buckets for the account. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise




def teardown(user, role):
    """
    Removes all resources created during setup.

    :param user: The demo user.
    :param role: The demo role.
    """
    try:
        for attached in role.attached_policies.all():
            policy_name = attached.policy_name
            role.detach_policy(PolicyArn=attached.arn)
            attached.delete()
            print(f"Detached and deleted {policy_name}.")
        role.delete()
        print(f"Deleted {role.name}.")
    except ClientError as error:
        print(
            "Couldn't detach policy, delete policy, or delete role. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        for user_pol in user.policies.all():
            user_pol.delete()
            print("Deleted inline user policy.")
        for key in user.access_keys.all():
            key.delete()
            print("Deleted user's access key.")
        user.delete()
        print(f"Deleted {user.name}.")
    except ClientError as error:
        print(
            "Couldn't delete user policy or delete user. Here's why: "
            f"{error.response['Error']['Message']}"
        )


def usage_demo():
    """Drives the demonstration."""
    print("-" * 88)
    print(f"Welcome to the IAM create user and assume role demo.")
    print("-" * 88)
    iam_resource = boto3.resource("iam")
    user = None
    role = None
    try:
        user, user_key, role = setup(iam_resource)
        print(f"Created {user.name} and {role.name}.")
        show_access_denied_without_role(user_key)
        list_buckets_from_assumed_role(user_key, role.arn, "AssumeRoleDemoSession")
    except Exception:
        print("Something went wrong!")
    finally:
        if user is not None and role is not None:
            teardown(user, role)
        print("Thanks for watching!")


if __name__ == "__main__":
    usage_demo()
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para Python (Boto3)*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/PutUserPolicy)

------
#### [ Ruby ]

**SDK para Ruby**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/iam#code-examples). 
Cree un usuario de IAM y un rol que conceda permiso para enumerar los buckets de Amazon S3. El usuario solo tiene derechos para asumir el rol. Después de asumir el rol, use las credenciales temporales para enumerar los buckets de la cuenta.  

```
# Wraps the scenario actions.
class ScenarioCreateUserAssumeRole
  attr_reader :iam_client

  # @param [Aws::IAM::Client] iam_client: The AWS IAM client.
  def initialize(iam_client, logger: Logger.new($stdout))
    @iam_client = iam_client
    @logger = logger
  end

  # Waits for the specified number of seconds.
  #
  # @param duration [Integer] The number of seconds to wait.
  def wait(duration)
    puts('Give AWS time to propagate resources...')
    sleep(duration)
  end

  # Creates a user.
  #
  # @param user_name [String] The name to give the user.
  # @return [Aws::IAM::User] The newly created user.
  def create_user(user_name)
    user = @iam_client.create_user(user_name: user_name).user
    @logger.info("Created demo user named #{user.user_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info('Tried and failed to create demo user.')
    @logger.info("\t#{e.code}: #{e.message}")
    @logger.info("\nCan't continue the demo without a user!")
    raise
  else
    user
  end

  # Creates an access key for a user.
  #
  # @param user [Aws::IAM::User] The user that owns the key.
  # @return [Aws::IAM::AccessKeyPair] The newly created access key.
  def create_access_key_pair(user)
    user_key = @iam_client.create_access_key(user_name: user.user_name).access_key
    @logger.info("Created accesskey pair for user #{user.user_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create access keys for user #{user.user_name}.")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  else
    user_key
  end

  # Creates a role that can be assumed by a user.
  #
  # @param role_name [String] The name to give the role.
  # @param user [Aws::IAM::User] The user who is granted permission to assume the role.
  # @return [Aws::IAM::Role] The newly created role.
  def create_role(role_name, user)
    trust_policy = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Principal: { 'AWS': user.arn },
        Action: 'sts:AssumeRole'
      }]
    }.to_json
    role = @iam_client.create_role(
      role_name: role_name,
      assume_role_policy_document: trust_policy
    ).role
    @logger.info("Created role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create a role for the demo. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  else
    role
  end

  # Creates a policy that grants permission to list S3 buckets in the account, and
  # then attaches the policy to a role.
  #
  # @param policy_name [String] The name to give the policy.
  # @param role [Aws::IAM::Role] The role that the policy is attached to.
  # @return [Aws::IAM::Policy] The newly created policy.
  def create_and_attach_role_policy(policy_name, role)
    policy_document = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Action: 's3:ListAllMyBuckets',
        Resource: 'arn:aws:s3:::*'
      }]
    }.to_json
    policy = @iam_client.create_policy(
      policy_name: policy_name,
      policy_document: policy_document
    ).policy
    @iam_client.attach_role_policy(
      role_name: role.role_name,
      policy_arn: policy.arn
    )
    @logger.info("Created policy #{policy.policy_name} and attached it to role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create a policy and attach it to role #{role.role_name}. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Creates an inline policy for a user that lets the user assume a role.
  #
  # @param policy_name [String] The name to give the policy.
  # @param user [Aws::IAM::User] The user that owns the policy.
  # @param role [Aws::IAM::Role] The role that can be assumed.
  # @return [Aws::IAM::UserPolicy] The newly created policy.
  def create_user_policy(policy_name, user, role)
    policy_document = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Action: 'sts:AssumeRole',
        Resource: role.arn
      }]
    }.to_json
    @iam_client.put_user_policy(
      user_name: user.user_name,
      policy_name: policy_name,
      policy_document: policy_document
    )
    puts("Created an inline policy for #{user.user_name} that lets the user assume role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create an inline policy for user #{user.user_name}. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Creates an Amazon S3 resource with specified credentials. This is separated into a
  # factory function so that it can be mocked for unit testing.
  #
  # @param credentials [Aws::Credentials] The credentials used by the Amazon S3 resource.
  def create_s3_resource(credentials)
    Aws::S3::Resource.new(client: Aws::S3::Client.new(credentials: credentials))
  end

  # Lists the S3 buckets for the account, using the specified Amazon S3 resource.
  # Because the resource uses credentials with limited access, it may not be able to
  # list the S3 buckets.
  #
  # @param s3_resource [Aws::S3::Resource] An Amazon S3 resource.
  def list_buckets(s3_resource)
    count = 10
    s3_resource.buckets.each do |bucket|
      @logger.info "\t#{bucket.name}"
      count -= 1
      break if count.zero?
    end
  rescue Aws::Errors::ServiceError => e
    if e.code == 'AccessDenied'
      puts('Attempt to list buckets with no permissions: AccessDenied.')
    else
      @logger.info("Couldn't list buckets for the account. Here's why: ")
      @logger.info("\t#{e.code}: #{e.message}")
      raise
    end
  end

  # Creates an AWS Security Token Service (AWS STS) client with specified credentials.
  # This is separated into a factory function so that it can be mocked for unit testing.
  #
  # @param key_id [String] The ID of the access key used by the STS client.
  # @param key_secret [String] The secret part of the access key used by the STS client.
  def create_sts_client(key_id, key_secret)
    Aws::STS::Client.new(access_key_id: key_id, secret_access_key: key_secret)
  end

  # Gets temporary credentials that can be used to assume a role.
  #
  # @param role_arn [String] The ARN of the role that is assumed when these credentials
  #                          are used.
  # @param sts_client [AWS::STS::Client] An AWS STS client.
  # @return [Aws::AssumeRoleCredentials] The credentials that can be used to assume the role.
  def assume_role(role_arn, sts_client)
    credentials = Aws::AssumeRoleCredentials.new(
      client: sts_client,
      role_arn: role_arn,
      role_session_name: 'create-use-assume-role-scenario'
    )
    @logger.info("Assumed role '#{role_arn}', got temporary credentials.")
    credentials
  end

  # Deletes a role. If the role has policies attached, they are detached and
  # deleted before the role is deleted.
  #
  # @param role_name [String] The name of the role to delete.
  def delete_role(role_name)
    @iam_client.list_attached_role_policies(role_name: role_name).attached_policies.each do |policy|
      @iam_client.detach_role_policy(role_name: role_name, policy_arn: policy.policy_arn)
      @iam_client.delete_policy(policy_arn: policy.policy_arn)
      @logger.info("Detached and deleted policy #{policy.policy_name}.")
    end
    @iam_client.delete_role({ role_name: role_name })
    @logger.info("Role deleted: #{role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't detach policies and delete role #{role.name}. Here's why:")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Deletes a user. If the user has inline policies or access keys, they are deleted
  # before the user is deleted.
  #
  # @param user [Aws::IAM::User] The user to delete.
  def delete_user(user_name)
    user = @iam_client.list_access_keys(user_name: user_name).access_key_metadata
    user.each do |key|
      @iam_client.delete_access_key({ access_key_id: key.access_key_id, user_name: user_name })
      @logger.info("Deleted access key #{key.access_key_id} for user '#{user_name}'.")
    end

    @iam_client.delete_user(user_name: user_name)
    @logger.info("Deleted user '#{user_name}'.")
  rescue Aws::IAM::Errors::ServiceError => e
    @logger.error("Error deleting user '#{user_name}': #{e.message}")
  end
end

# Runs the IAM create a user and assume a role scenario.
def run_scenario(scenario)
  puts('-' * 88)
  puts('Welcome to the IAM create a user and assume a role demo!')
  puts('-' * 88)
  user = scenario.create_user("doc-example-user-#{Random.uuid}")
  user_key = scenario.create_access_key_pair(user)
  scenario.wait(10)
  role = scenario.create_role("doc-example-role-#{Random.uuid}", user)
  scenario.create_and_attach_role_policy("doc-example-role-policy-#{Random.uuid}", role)
  scenario.create_user_policy("doc-example-user-policy-#{Random.uuid}", user, role)
  scenario.wait(10)
  puts('Try to list buckets with credentials for a user who has no permissions.')
  puts('Expect AccessDenied from this call.')
  scenario.list_buckets(
    scenario.create_s3_resource(Aws::Credentials.new(user_key.access_key_id, user_key.secret_access_key))
  )
  puts('Now, assume the role that grants permission.')
  temp_credentials = scenario.assume_role(
    role.arn, scenario.create_sts_client(user_key.access_key_id, user_key.secret_access_key)
  )
  puts('Here are your buckets:')
  scenario.list_buckets(scenario.create_s3_resource(temp_credentials))
  puts("Deleting role '#{role.role_name}' and attached policies.")
  scenario.delete_role(role.role_name)
  puts("Deleting user '#{user.user_name}', policies, and keys.")
  scenario.delete_user(user.user_name)
  puts('Thanks for watching!')
  puts('-' * 88)
rescue Aws::Errors::ServiceError => e
  puts('Something went wrong with the demo.')
  puts("\t#{e.code}: #{e.message}")
end

run_scenario(ScenarioCreateUserAssumeRole.new(Aws::IAM::Client.new)) if $PROGRAM_NAME == __FILE__
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *referencia de la API de AWS SDK para Ruby*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Rust ]

**SDK para Rust**  
 Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples). 

```
use aws_config::meta::region::RegionProviderChain;
use aws_sdk_iam::Error as iamError;
use aws_sdk_iam::{config::Credentials as iamCredentials, config::Region, Client as iamClient};
use aws_sdk_s3::Client as s3Client;
use aws_sdk_sts::Client as stsClient;
use tokio::time::{sleep, Duration};
use uuid::Uuid;

#[tokio::main]
async fn main() -> Result<(), iamError> {
    let (client, uuid, list_all_buckets_policy_document, inline_policy_document) =
        initialize_variables().await;

    if let Err(e) = run_iam_operations(
        client,
        uuid,
        list_all_buckets_policy_document,
        inline_policy_document,
    )
    .await
    {
        println!("{:?}", e);
    };

    Ok(())
}

async fn initialize_variables() -> (iamClient, String, String, String) {
    let region_provider = RegionProviderChain::first_try(Region::new("us-west-2"));

    let shared_config = aws_config::from_env().region(region_provider).load().await;
    let client = iamClient::new(&shared_config);
    let uuid = Uuid::new_v4().to_string();

    let list_all_buckets_policy_document = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]
    }"
    .to_string();
    let inline_policy_document = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"{}\"}]
    }"
    .to_string();

    (
        client,
        uuid,
        list_all_buckets_policy_document,
        inline_policy_document,
    )
}

async fn run_iam_operations(
    client: iamClient,
    uuid: String,
    list_all_buckets_policy_document: String,
    inline_policy_document: String,
) -> Result<(), iamError> {
    let user = iam_service::create_user(&client, &format!("{}{}", "iam_demo_user_", uuid)).await?;
    println!("Created the user with the name: {}", user.user_name());
    let key = iam_service::create_access_key(&client, user.user_name()).await?;

    let assume_role_policy_document = "{
        \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }"
    .to_string()
    .replace("{}", user.arn());

    let assume_role_role = iam_service::create_role(
        &client,
        &format!("{}{}", "iam_demo_role_", uuid),
        &assume_role_policy_document,
    )
    .await?;
    println!("Created the role with the ARN: {}", assume_role_role.arn());

    let list_all_buckets_policy = iam_service::create_policy(
        &client,
        &format!("{}{}", "iam_demo_policy_", uuid),
        &list_all_buckets_policy_document,
    )
    .await?;
    println!(
        "Created policy: {}",
        list_all_buckets_policy.policy_name.as_ref().unwrap()
    );

    let attach_role_policy_result =
        iam_service::attach_role_policy(&client, &assume_role_role, &list_all_buckets_policy)
            .await?;
    println!(
        "Attached the policy to the role: {:?}",
        attach_role_policy_result
    );

    let inline_policy_name = format!("{}{}", "iam_demo_inline_policy_", uuid);
    let inline_policy_document = inline_policy_document.replace("{}", assume_role_role.arn());
    iam_service::create_user_policy(&client, &user, &inline_policy_name, &inline_policy_document)
        .await?;
    println!("Created inline policy.");

    //First, fail to list the buckets with the user.
    let creds = iamCredentials::from_keys(key.access_key_id(), key.secret_access_key(), None);
    let fail_config = aws_config::from_env()
        .credentials_provider(creds.clone())
        .load()
        .await;
    println!("Fail config: {:?}", fail_config);
    let fail_client: s3Client = s3Client::new(&fail_config);
    match fail_client.list_buckets().send().await {
        Ok(e) => {
            println!("This should not run. {:?}", e);
        }
        Err(e) => {
            println!("Successfully failed with error: {:?}", e)
        }
    }

    let sts_config = aws_config::from_env()
        .credentials_provider(creds.clone())
        .load()
        .await;
    let sts_client: stsClient = stsClient::new(&sts_config);
    sleep(Duration::from_secs(10)).await;
    let assumed_role = sts_client
        .assume_role()
        .role_arn(assume_role_role.arn())
        .role_session_name(format!("iam_demo_assumerole_session_{uuid}"))
        .send()
        .await;
    println!("Assumed role: {:?}", assumed_role);
    sleep(Duration::from_secs(10)).await;

    let assumed_credentials = iamCredentials::from_keys(
        assumed_role
            .as_ref()
            .unwrap()
            .credentials
            .as_ref()
            .unwrap()
            .access_key_id(),
        assumed_role
            .as_ref()
            .unwrap()
            .credentials
            .as_ref()
            .unwrap()
            .secret_access_key(),
        Some(
            assumed_role
                .as_ref()
                .unwrap()
                .credentials
                .as_ref()
                .unwrap()
                .session_token
                .clone(),
        ),
    );

    let succeed_config = aws_config::from_env()
        .credentials_provider(assumed_credentials)
        .load()
        .await;
    println!("succeed config: {:?}", succeed_config);
    let succeed_client: s3Client = s3Client::new(&succeed_config);
    sleep(Duration::from_secs(10)).await;
    match succeed_client.list_buckets().send().await {
        Ok(_) => {
            println!("This should now run successfully.")
        }
        Err(e) => {
            println!("This should not run. {:?}", e);
            panic!()
        }
    }

    //Clean up.
    iam_service::detach_role_policy(
        &client,
        assume_role_role.role_name(),
        list_all_buckets_policy.arn().unwrap_or_default(),
    )
    .await?;
    iam_service::delete_policy(&client, list_all_buckets_policy).await?;
    iam_service::delete_role(&client, &assume_role_role).await?;
    println!("Deleted role {}", assume_role_role.role_name());
    iam_service::delete_access_key(&client, &user, &key).await?;
    println!("Deleted key for {}", key.user_name());
    iam_service::delete_user_policy(&client, &user, &inline_policy_name).await?;
    println!("Deleted inline user policy: {}", inline_policy_name);
    iam_service::delete_user(&client, &user).await?;
    println!("Deleted user {}", user.user_name());

    Ok(())
}
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para Rust*.
  + [AttachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.attach_role_policy)
  + [CreateAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_access_key)
  + [CreatePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_policy)
  + [CreateRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_role)
  + [CreateUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_user)
  + [DeleteAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_access_key)
  + [DeletePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_policy)
  + [DeleteRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_role)
  + [DeleteUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user)
  + [DeleteUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user_policy)
  + [DetachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.detach_role_policy)
  + [PutUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.put_user_policy)

------

# Utilizar un rol de IAM para conceder permisos a aplicaciones que se ejecutan en instancias de Amazon EC2
<a name="id_roles_use_switch-role-ec2"></a>

Las aplicaciones que se ejecutan en una instancia de Amazon EC2 deben incluir credenciales de AWS en sus solicitudes de API de AWS. Los desarrolladores pueden almacenar las credenciales de AWS directamente en la instancia de Amazon EC2 y permitir que las aplicaciones de dicha instancia las utilicen. Sin embargo, los desarrolladores tendrían que encargarse de administrar las credenciales, así como asegurarse de transferirlas de forma segura a cada instancia y actualizar cada instancia de Amazon EC2 cuando haya que actualizar las credenciales. Todo esto supone mucho trabajo adicional.

En su lugar, puede y debe utilizar un rol de IAM para administrar las credenciales *temporales* de las aplicaciones que se ejecutan en una instancia de Amazon EC2. Al utilizar un rol, no tiene que distribuir credenciales a largo plazo (como credenciales de inicio de sesión o claves de acceso) a una instancia de Amazon EC2. En vez de ello, el rol proporciona permisos temporales que las aplicaciones pueden utilizar al realizar llamadas a otros recursos de AWS. Cuando lanza una instancia de Amazon EC2, usted especifica un rol de IAM que se asocia a la instancia. Esto permite a las aplicaciones que se ejecutan en dicha instancia utilizar las credenciales temporales facilitadas por el rol para firmar las solicitudes de API.

El uso de roles para conceder permisos a aplicaciones que se ejecutan en instancias de Amazon EC2 requiere una configuración adicional. El sistema operativo virtualizado extrae de AWS una aplicación que se ejecuta en una instancia de Amazon EC2. Debido a esta separación adicional, necesita un paso más para asignar un rol de AWS y sus permisos asociados a una instancia de Amazon EC2 y para ponerlos a disposición de las aplicaciones. Este paso adicional consiste en crear un *[perfil de instancia](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html)* asociado a la instancia. El perfil de instancia contiene el rol y puede proporcionar las credenciales temporales de este a una aplicación que se ejecute en la instancia. La aplicación, a su vez, puede utilizar estas credenciales temporales en las llamadas a la API para obtener acceso a los recursos y para restringir el acceso únicamente a aquellos recursos que el rol especifica.

**nota**  
Solo se puede asignar un rol a la vez a una instancia de Amazon EC2 y todas las aplicaciones en la instancia comparten ese mismo rol y permisos. Cuando aprovecha Amazon ECS para administrar las instancias de Amazon EC2, puede asignar roles a las tareas de Amazon ECS que pueden distinguirse del rol de la instancia de Amazon EC2 en la que se ejecutan. La asignación de un rol a cada tarea se ajusta al principio de acceso con privilegio mínimo y permite un mayor control pormenorizado de acciones y recursos.  
Para obtener más información, consulte [Uso de roles de IAM con tareas de Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/security-iam-roles.html) en la *Guía de prácticas recomendadas para Amazon Elastic Container Service*.

Este uso de los roles tiene varios beneficios. Dado que las credenciales del rol son temporales y se actualizan de forma automática, no es necesario administrar las credenciales ni preocuparse por los riesgos de seguridad a largo plazo. Además, si utiliza un único rol para varias instancias, puede especificar un cambio en ese rol y el cambio se propagará automáticamente a todas las instancias. 

**nota**  
Aunque normalmente un rol se asigna a una instancia de Amazon EC2 cuando esta se lanza, también se puede asociar un rol a una instancia de Amazon EC2 que ya esté en ejecución. Para obtener información sobre cómo asociar una función a una instancia en ejecución, consulte [Roles de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).

**Topics**
+ [

## ¿Cómo funcionan los roles de instancias de Amazon EC2?
](#roles-usingrole-ec2instance-roles)
+ [

## Permisos necesarios para utilizar roles con Amazon EC2
](#roles-usingrole-ec2instance-permissions)
+ [

## ¿Cómo puedo comenzar?
](#roles-usingrole-ec2instance-get-started)
+ [

## Información relacionada
](#roles-usingrole-ec2instance-related-info)

## ¿Cómo funcionan los roles de instancias de Amazon EC2?
<a name="roles-usingrole-ec2instance-roles"></a>

En la figura siguiente, un desarrollador ejecuta una aplicación en una instancia de Amazon EC2 que necesita obtener acceso a un bucket de S3 denominado `amzn-s3-demo-bucket-photos`. Un administrador crea el rol de servicio `Get-pics` y lo asocia a la instancia de Amazon EC2. El rol incluye una política de permisos que otorga acceso de solo lectura al bucket de S3 especificado. También incluye una política de confianza que permite a la instancia de Amazon EC2 asumir el rol y obtener las credenciales temporales. Cuando la aplicación se ejecuta en la instancia, puede utilizar las credenciales temporales del rol para obtener acceso al bucket photos. El administrador no tiene que conceder al desarrollador permiso para acceder al bucket photos y el desarrollador no tiene que compartir ni administrar en ningún momento las credenciales.

![\[Aplicación en una instancia de Amazon EC2 que obtiene acceso a un recurso de AWS\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/roles-usingrole-ec2roleinstance.png)


1. El administrador usa IAM para crear el rol **Get-pics**. En la política de confianza del rol, el administrador especifica que solo las instancias de Amazon EC2 pueden asumir el rol. En la política de permisos del rol, el administrador especifica permisos de solo lectura para el bucket `amzn-s3-demo-bucket-photos`.

1. Un desarrollador lanza una instancia de Amazon EC2 y asigna el rol `Get-pics` a dicha instancia.
**nota**  
Si utiliza la consola de IAM, el perfil de instancias se administra de forma prácticamente transparente en su lugar. Sin embargo, si utiliza la AWS CLI o la API para crear y administrar el rol y la instancia de Amazon EC2, debe crear el perfil de instancia y asignarle el rol en pasos diferentes. A continuación, al lanzar la instancia, debe especificar el nombre del perfil de instancia en lugar del nombre del rol.

1. Cuando se ejecuta la aplicación, esta obtiene credenciales de seguridad temporales desde los [metadatos de instancias](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) de Amazon EC2, tal y como se describe en [Recuperación de las credenciales de seguridad en los metadatos de la instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials). Se trata de las [credenciales de seguridad temporales](id_credentials_temp.md) que representan el rol y son válidas durante un periodo de tiempo limitado. 

   Con algunos [AWS SDKs](https://aws.amazon.com/tools/), el desarrollador puede utilizar un proveedor que administre las credenciales de seguridad temporales de forma transparente. (La documentación de los SDK AWS individuales describe las características compatibles con el SDK de administración de credenciales).

   De forma alternativa, la aplicación puede obtener credenciales temporales directamente desde los metadatos de la instancia de Amazon EC2. Las credenciales y los valores asociados están disponibles en la categoría `iam/security-credentials/role-name` (en este caso, `iam/security-credentials/Get-pics`) de los metadatos. Si la aplicación obtiene las credenciales de los metadatos de la instancia, puede almacenar en caché las credenciales.

1. Con las credenciales temporales recuperadas, la aplicación obtiene acceso al bucket photo. Debido a la política asociada al rol **Get-pics**, la aplicación tiene permisos de solo lectura. 

   Las credenciales de seguridad temporales disponibles en la instancia se actualizan de manera automática antes de caducar, de modo que siempre haya un conjunto válido disponible. La aplicación solo debe asegurarse de obtener un conjunto nuevo de credenciales de los metadatos de la instancia antes de que las credenciales actuales caduquen. Es posible utilizar el AWS SDK para administrar credenciales, de modo que la aplicación no necesite incluir lógica adicional para actualizar las credenciales. Por ejemplo, crear instancias de clientes con proveedores de credenciales de perfil de instancia. No obstante, si la aplicación obtiene las credenciales de seguridad temporales de los metadatos de la instancia y los almacena en caché, debería obtener un conjunto de credenciales actualizado cada hora, o al menos 15 minutos antes de que el conjunto en curso caduque. El plazo de vencimiento está indicado en la información devuelta, en la categoría `iam/security-credentials/role-name`. 

## Permisos necesarios para utilizar roles con Amazon EC2
<a name="roles-usingrole-ec2instance-permissions"></a>

Para lanzar una instancia con un rol, el desarrollador debe tener permiso para lanzar instancias de Amazon EC2 y transferir roles de IAM.

La siguiente política de ejemplo permite a los usuarios utilizar la Consola de administración de AWS para lanzar una instancia con un rol. La política incluye comodines (`*`) para permitir a los usuarios transferir cualquier rol y llevar a cabo las acciones de Amazon EC2 mencionadas. La acción `ListInstanceProfiles` permite a los usuarios ver todos los roles disponibles en la Cuenta de AWS.

**Example Ejemplo de política que concede permiso a un usuario para utilizar la consola de Amazon EC2 para lanzar una instancia con cualquier rol**    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "IamPassRole",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "ec2.amazonaws.com"
                }
            }
        },
        {
            "Sid": "ListEc2AndListInstanceProfiles",
            "Effect": "Allow",
            "Action": [
                "iam:ListInstanceProfiles",
                "ec2:Describe*",
                "ec2:Search*",
                "ec2:Get*"
            ],
            "Resource": "*"
        }
    ]
}
```

### Restricción de los roles que se pueden transferir a instancias de Amazon EC2 (usando PassRole)
<a name="roles-usingrole-ec2instance-passrole"></a>

Puede utilizar el permiso `PassRole` para restringir qué rol puede transferir un usuario a una instancia de Amazon EC2 cuando el usuario lanza la instancia. Esto es útil para evitar que el usuario ejecute aplicaciones que tengan más permisos de los que se le han concedido; es decir, evita que se puedan obtener privilegios superiores. Por ejemplo, supongamos que la usuaria Alice tenga permiso solo para lanzar instancias de Amazon EC2 y trabajar con buckets de Amazon S3, pero el rol que pasa a una instancia de Amazon EC2 tiene permisos para trabajar con IAM y Amazon DynamoDB. En este caso, Alice podría lanzar la instancia, iniciar sesión en ella, obtener credenciales de seguridad temporales y, a continuación, realizar acciones de IAM o DynamoDB para las que carece de autorización.

Para restringir los roles que un usuario puede transferir a una instancia de Amazon EC2, debe crear una política que permita la acción `PassRole`. A continuación, debe asociar la política al usuario (o a un grupo de IAM al que pertenezca el usuario), el cual, a su vez, lanzará las instancias de Amazon EC2. En el elemento `Resource` de la política, se genera una lista con el rol o los roles que el usuario tiene permiso para transferir a las instancias de Amazon EC2. Cuando el usuario lanza una instancia y le asocia un rol, Amazon EC2 comprueba si el usuario tiene permiso para transmitir dicho rol. Desde luego, también debe asegurarse de que el rol que el usuario puede transferir no incluya más permisos de los que se supone que debe tener el usuario.

**nota**  
`PassRole` no es una acción de API de la misma forma que `RunInstances` o `ListInstanceProfiles`. Se trata de un permiso que AWS comprueba siempre que un ARN de rol se transfiere como parámetro a una API (o la consola se encarga de ello en nombre del usuario). Sirve de ayuda para que el administrador controle qué roles pueden pasar según qué usuarios. En este caso, se asegura de que el usuario pueda asociar un rol específico a una instancia de Amazon EC2.

**Example Ejemplo de política que concede permiso a un usuario para lanzar una instancia de Amazon EC2 con un rol concreto**  
La siguiente política de ejemplo permite a los usuarios utilizar la API de Amazon EC2 para lanzar una instancia con un rol. El elemento `Resource` especifica el nombre de recurso de Amazon (ARN) de un rol. Al especificar el ARN, la política concede al usuario permiso para transferir únicamente el rol `Get-pics`. Si el usuario intenta especificar otro rol al lanzar una instancia, la acción dará un error. El usuario tiene permisos para ejecutar cualquier instancia, independientemente de si transmiten una función.    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "ec2:RunInstances",
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::111122223333:role/Get-pics"
        }
    ]
}
```

### Permitir que una función de perfil de instancia cambie una función en otra cuenta
<a name="switch-role-ec2-another-account"></a>

Puede permitir que una aplicación que se ejecuta en una instancia de Amazon EC2 ejecute comandos en otra cuenta. Para ello, debe permitir el rol de instancia de Amazon EC2 en la primera cuenta para cambiar a una función en la segunda cuenta.

Imagine que está utilizando dos Cuentas de AWS y desea permitir que una aplicación se ejecute en una instancia de Amazon EC2 para ejecutar comandos [AWS CLI](https://aws.amazon.com/cli/) en ambas cuentas. Supongamos que la instancia de Amazon EC2 existe en la cuenta `111111111111`. Dicha instancia incluye la función de perfil de instancias `abcd` que permite que la aplicación realice tareas de solo lectura de Amazon S3 en el bucket `amzn-s3-demo-bucket1` dentro de la misma cuenta `111111111111`. Sin embargo, la aplicación también debe tener permitido asumir la función entre cuentas `efgh` para acceder al bucket `amzn-s3-demo-bucket2` Amazon S3 de la cuenta `222222222222`.

![\[En el diagrama, se muestra cómo un desarrollador inicia una instancia de Amazon EC2 con el rol para acceder a las fotos almacenadas en un bucket de Amazon S3.\]](http://docs.aws.amazon.com/es_es/IAM/latest/UserGuide/images/roles-instance-profile-cross-account.png)


Para ello, la función del perfil de instancia de Amazon EC2 `abcd` debe tener la siguiente política de permisos para permitir que la aplicación acceda al bucket `amzn-s3-demo-bucket1` Amazon S3:

***Política de permisos del rol de la cuenta 111111111111 `abcd`***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket1/*",
                "arn:aws:s3:::amzn-s3-demo-bucket1"
            ]
        },
        {
            "Sid": "AllowIPToAssumeCrossAccountRole",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::222222222222:role/efgh"
        }
    ]
}
```

------

El rol `abcd` debe confiar en el servicio Amazon EC2 para asumir la función. Para ello, la función `abcd` debe tener la siguiente política de confianza:

***Política de confianza de rol `abcd` de la cuenta 111111111111 ***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "abcdTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"Service": "ec2.amazonaws.com"}
        }
    ]
}
```

------

Supongamos que la función entre cuentas `efgh` permite tareas de solo lectura de Amazon S3 en el bucket `amzn-s3-demo-bucket2` dentro de la misma cuenta `222222222222`. Para ello, la función entre cuentas `efgh` debe tener la siguiente política de permisos:

***Política de permisos del rol de la cuenta 222222222222 `efgh`***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket2/*",
                "arn:aws:s3:::amzn-s3-demo-bucket2"
            ]
        }
    ]
}
```

------

La función `efgh` debe confiar en la función de perfil de instancia `abcd` para asumirla. Para ello, la función `efgh` debe tener la siguiente política de confianza:

***Política de confianza de rol `efgh` de la cuenta 222222222222 ***

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "efghTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"}
        }
    ]
}
```

------

## ¿Cómo puedo comenzar?
<a name="roles-usingrole-ec2instance-get-started"></a>

Para comprender cómo funcionan los roles con instancias de Amazon EC2, debe utilizar la consola de IAM para crear un rol, lanzar una instancia de Amazon EC2 que utilice dicho rol y, a continuación, estudiar la instancia mientras se ejecuta. Puede examinar los [metadatos de la instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) para ver cómo se ponen las credenciales temporales de la función a disposición de la instancia. También puede ver cómo una aplicación que ejecuta una instancia puede utilizar el rol. Utilice los siguientes recursos para obtener más información. 
+ [Tutorial de roles de IAM en instancias de Amazon EC2](https://www.youtube.com/watch?v=TlCuOjviOhk). El video del enlace muestra cómo utilizar un rol de IAM con una instancia de Amazon EC2 para controlar lo que una aplicación puede hacer cuando se ejecuta en la instancia. El vídeo muestra cómo la aplicación (escrita en el AWS SDK) puede obtener credenciales de seguridad temporales mediante el rol. 
+ Tutoriales de SDK. La documentación del SDK de AWS contiene explicaciones que muestran una aplicación que se ejecuta en una instancia de Amazon EC2 que utiliza credenciales temporales para los roles para leer un bucket de Amazon S3. Cada uno de los siguientes tutoriales presenta pasos similares con un lenguaje de programación diferente:
  + [Configuración de roles de IAM para Amazon EC2 con el SDK para Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java-dg-roles.html) en la *Guía para desarrolladores de AWS SDK para Java* 
  + [Inicie una instancia de Amazon EC2 utilizando el SDK para .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/run-instance.html) en la *Guía para el desarrollador de AWS SDK para .NET*
  + [Creación de una instancia de Amazon EC2 con el SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby/latest/developer-guide/ec2-example-create-instance.html) en la *Guía para el desarrollador de AWS SDK para Ruby*

## Información relacionada
<a name="roles-usingrole-ec2instance-related-info"></a>

Para obtener más información sobre cómo crear roles o roles para instancias de Amazon EC2, consulte la siguiente información:
+ Para obtener más información acerca de [Uso de roles de IAM con instancias de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html), consulte la *Guía del usuario de Amazon EC2*.
+ Para crear un rol, consulte [Creación de roles de IAM](id_roles_create.md)
+ Para obtener más información sobre cómo utilizar credenciales de seguridad temporales, consulte [Credenciales de seguridad temporales en IAM](id_credentials_temp.md).
+ Si trabaja con la API o la CLI IAM, debe crear y administrar perfiles de instancia de IAM. Para obtener más información sobre los perfiles de instancia, consulte [Utilizar perfiles de instancia](id_roles_use_switch-role-ec2_instance-profiles.md).
+ Para obtener más información sobre las credenciales de seguridad temporales para roles en los metadatos de la instancia, consulte [Recuperación de las credenciales de seguridad en los metadatos de la instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials) en la *Guía del usuario de Amazon EC2*.

# Utilizar perfiles de instancia
<a name="id_roles_use_switch-role-ec2_instance-profiles"></a>

Utilice un perfil de instancias para pasar un rol de IAM a una instancia EC2. Para obtener más información, consulte [Roles de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) en la *Guía del usuario de Amazon EC2*.

## Administración de perfiles de instancia (consola)
<a name="instance-profiles-manage-console"></a>

Si utiliza la Consola de administración de AWS para crear un rol para Amazon EC2, la consola crea automáticamente un perfil de instancias y le da el mismo nombre que al rol. Después, cuando utilice la consola Amazon EC2 para lanzar una instancia con un rol de IAM, puede seleccionar una función para asociarlo con la instancia. En la consola, la lista que se muestra es en realidad una lista de nombres de perfiles de instancia. La consola no crea un perfil de instancias para un rol que no está asociado a Amazon EC2.

Puede utilizar el Consola de administración de AWS para eliminar roles de IAM y perfiles de instancia de Amazon EC2 si el rol y el perfil de instancias tienen el mismo nombre. Para obtener más información acerca de la eliminación de perfiles de instancia, consulte [Eliminar roles o perfiles de instancia](id_roles_manage_delete.md).

**nota**  
Para actualizar los permisos de una instancia, sustituya su perfil de instancia. No recomendamos eliminar un rol de un perfil de instancia, ya que este cambio tarda hasta una hora en surtir efecto.

## Administración de perfiles de instancias (AWS CLI o API de AWS)
<a name="instance-profiles-manage-cli-api"></a>

Si administra sus roles en la AWS CLI o la API de AWS, crea los roles y los perfiles de instancias como acciones independientes. Debido a que los roles y los perfiles de instancias puede tener nombres diferentes, debe saber los nombres de sus perfiles de instancia, así como los nombres de los roles que contienen. De esta forma, puede elegir el perfil de instancia correcto cuando lance una instancia EC2. 

Puede asociar etiquetas a los recursos de IAM, incluidos los perfiles de instancia, a fin de identificar, organizar y controlar el acceso a ellos. Solo puede etiquetar perfiles de instancia cuando utiliza la AWS CLI o la API de AWS. 

**nota**  
Un perfil de instancias puede contener un único rol de IAM, aunque un rol puede incluirse en varios perfiles de instancias. Este límite de un rol por perfil de instancia no puede aumentarse. Puede eliminar el rol existente y, a continuación, agregar un rol diferente a un perfil de instancia. A continuación, debe esperar a que el cambio aparezca en todo AWS, a causa de la [consistencia final](https://en.wikipedia.org/wiki/Eventual_consistency). Para forzar el cambio, debe [desvincular el perfil de instancia](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html) y, a continuación, [asociar el perfil de instancia](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html), o bien puede detener la instancia y después reiniciarla.

### Administración de perfiles de instancias (AWS CLI)
<a name="instance-profiles-manage-cli"></a>

Puede utilizar los siguientes comandos de la AWS CLI para trabajar con perfiles de instancia en una cuenta de AWS. 
+ Creación de un perfil de instancia: [https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html)
+ Etiquetado de un perfil de instancia: [https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html)
+ Enumeración de etiquetas de un perfil de instancia: [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html)
+ Desetiquetado de un perfil de instancia: [https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html)
+ Añadir un rol a un perfil de instancia: [https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html) 
+ Enumeración de perfiles de instancia: [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html), [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html) 
+ Obtención de información sobre un perfil de instancia: [https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html) 
+ Eliminación de un rol de un perfil de instancia: [https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html)
+ Eliminación de un perfil de instancia: [https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html) 

También puede asociar un rol a una instancia EC2 que ya esté en ejecución ejecutando los siguientes comandos. Para obtener más información, consulte [Roles de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
+ Asociación de un perfil de instancia con un rol a una instancia EC2 en ejecución o detenida: [https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html) 
+ Obtención de información sobre un perfil de instancia asociado a una instancia EC: [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html) 
+ Separación de un perfil de instancia con un rol de una instancia EC2 en ejecución o detenida: [https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html) 

### Administración de perfiles de instancias (API de AWS)
<a name="instance-profiles-manage-api"></a>

Puede llamar a las siguientes operaciones de la API de AWS para trabajar con perfiles de instancia en una Cuenta de AWS.
+ Creación de un perfil de instancia: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html) 
+ Etiquetado de un perfil de instancia: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Enumeración de etiquetas de un perfil de instancia: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Desetiquetado de un perfil de instancia: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Añadir un rol a un perfil de instancia: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html) 
+ Enumeración de perfiles de instancia: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html), [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html) 
+ Obtención de información sobre un perfil de instancia: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html) 
+ Eliminación de un rol de un perfil de instancia: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html) 
+ Eliminación de un perfil de instancia: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html) 

También puede asociar un rol a una instancia EC2 que ya esté en ejecución llamando a las siguientes operaciones. Para obtener más información, consulte [Roles de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
+ Asociación de un perfil de instancia con un rol a una instancia EC2 en ejecución o detenida: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html) 
+ Obtención de información sobre un perfil de instancia asociado a una instancia EC: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html) 
+ Separación de un perfil de instancia con un rol de una instancia EC2 en ejecución o detenida: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html)