# Permitir el acceso del agente de identidades personalizadas a la consola de AWS
<a name="id_roles_providers_enable-console-custom-url"></a>

Puede escribir y ejecutar código para crear una dirección URL que permita a los usuarios que inicien sesión en la red de su organización obtener acceso de forma segura a la Consola de administración de AWS. La dirección URL incluye un token de inicio de sesión que obtiene de AWS y que autentica al usuario en AWS. La sesión de la consola resultante puede incluir una función `AccessKeyId` distinta debido a la federación. Para rastrear el uso de la clave de acceso para el inicio de sesión de la federación a través de eventos de CloudTrail relacionados, consulte [Registro de llamadas a IAM y a la API de AWS STS con AWS CloudTrail](cloudtrail-integration.md) y [los eventos de inicio de sesión de Consola de administración de AWS](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-aws-console-sign-in-events.html). 

**nota**  
Si su organización usa un proveedor de identidad (IdP) que es compatible con SAML, puede configurar el acceso a la consola sin necesidad de escribir código. Funciona con proveedores como Active Directory Federation Services de Microsoft o Shibboleth de código abierto. Para obtener más información, 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). 

Para permitir que los usuarios de su organización tengan acceso a la Consola de administración de AWS, puede crear un *agente de identidades* que realice los pasos siguientes:

1. Comprobar que el sistema de identidad local autentique al usuario.

1. Llame a las operaciones de la API [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) (recomendado) o [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html) de AWS Security Token Service (AWS STS) para obtener credenciales de seguridad temporales para el usuario. 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). Para obtener información sobre cómo pasar etiquetas de sesión opcionales al obtener las credenciales de seguridad, consulte [Transferencia de etiquetas de sesión en AWS STS](id_session-tags.md).
   + Si utiliza una de las operaciones `AssumeRole*` de la API para obtener las credenciales de seguridad temporales de un rol, puede incluir el parámetro `DurationSeconds` en la llamada. Este parámetro especifica 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. Cuando se utiliza `DurationSeconds` en una operación `AssumeRole*`, debe llamarla como un usuario de IAM con credenciales a largo plazo. De lo contrario, la llamada al punto de enlace de federación en el paso 3 produce un error. Para obtener información sobre cómo ver o cambiar el valor máximo para un 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 la operación `GetFederationToken` de la API para obtener las credenciales, puede incluir el parámetro `DurationSeconds` en la llamada. Este parámetro especifica la duración de la sesión de rol. Este valor puede oscilar entre 900 segundos (15 minutos) y 129 600 segundos (36 horas). Solo podrá realizar esta llamada a la API utilizando las credenciales de seguridad de AWS a largo plazo de un usuario de IAM. También puede realizar estas llamadas con las credenciales de Usuario raíz de la cuenta de AWS, pero no lo recomendamos. Si realiza esta llamada como usuario raíz, la duración predeterminada de la sesión es de una hora. También puede especificar una sesión que dure entre 900 segundos (15 minutos) y 3 600 segundos (una hora). 

1. Llame al punto de enlace de federación de AWS y proporcione las credenciales de seguridad temporales para solicitar un token de inicio de sesión.

1. Representar una URL de la consola que incluya el token:
   + Si utiliza una de las operaciones `AssumeRole*` de la API en la URL, puede incluir el parámetro HTTP `SessionDuration`. Este parámetro especifica la duración de la sesión de consola, que oscila entre 900 segundos (15 minutos) y 43 200 segundos (12 horas).
   + Si utiliza la operación `GetFederationToken` de la API en la URL, puede incluir el parámetro `DurationSeconds`. Este parámetro especifica la duración de la sesión de consola federada. Este valor puede oscilar entre 900 segundos (15 minutos) y 129 600 segundos (36 horas). 
**nota**  
Su `SessionDuration` no puede ser mayor o igual a la configuración de duración máxima de la sesión para el rol que está asumiendo. Por ejemplo, ha establecido en 5 horas la duración máxima de la sesión para el rol que desea asumir. Su parámetro `SessionDuration` puede ser de 16524 segundos o 4 horas y 59 segundos.
No utilice el parámetro HTTP `SessionDuration` si obtiene las credenciales temporales con `GetFederationToken`. La operación producirá un error.
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, las nuevas credenciales tienen una duración máxima de una hora. Cuando utiliza roles para [conceder permisos a las aplicaciones que se ejecutan en instancias EC2](id_roles_use_switch-role-ec2.md), esas aplicaciones no están sujetas a esta limitación.
No utilice el parámetro HTTP `SessionDuration` si obtiene las credenciales temporales mediante el encadenamiento de roles. La operación producirá un error.

1. Proporcione la dirección URL al usuario o invóquela en nombre del usuario.

La dirección URL que el punto de enlace de federación proporciona es válida durante 15 minutos después de su creación. Esto difiere de la duración (en segundos) de la sesión de credenciales de seguridad temporales que está asociada a la URL. Esas credenciales son válidas durante el periodo que especificó al crearlas, a partir del momento en que se crearon.

**importante**  
La dirección URL concede el acceso a sus recursos de AWS a través de la Consola de administración de AWS si ha habilitado los permisos en las credenciales de seguridad temporales asociadas. Por este motivo, debe tratar a la dirección URL como un secreto. Recomendamos devolver la dirección URL a través de un redireccionamiento seguro, por ejemplo, mediante la utilización de un código de estado de respuesta HTTP 302 a través de una conexión SSL. Para obtener más información sobre el código de estado de respuesta HTTP 302, diríjase a [RFC 2616, sección 10.3.3](https://datatracker.ietf.org/doc/html/rfc2616#section-10.3.3).

Para finalizar estas tareas, puede utilizar la API de consulta [HTTPS para AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/APIReference/) y [AWS Security Token Service (AWS STS)](https://docs.aws.amazon.com/STS/latest/APIReference/). O bien, puede utilizar lenguajes de programación, tales como Java, Ruby o C\$1, junto con el [SDK de AWS](https://aws.amazon.com/tools/) apropiado. En las siguientes secciones, se describe cada uno de estos métodos.

**Topics**
+ [Código de ejemplo con operaciones de API de consulta de IAM](#STSConsoleLink_manual)
+ [Ejemplo de código que utiliza Python](#STSConsoleLink_programPython)
+ [Ejemplo de código que utiliza Java](#STSConsoleLink_programJava)
+ [Ejemplo que muestra cómo crear la dirección URL (Ruby)](#STSConsoleLink_programRuby)

## Código de ejemplo con operaciones de API de consulta de IAM
<a name="STSConsoleLink_manual"></a>

Puede crear una URL que otorgue acceso directo a la Consola de administración de AWS a roles y entidades principales federadas. Esta tarea usa IAM y la API de consulta HTTPS de AWS STS. Para obtener más información sobre cómo realizar solicitudes de consulta, consulte [Making Query Requests](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html).

**nota**  
El siguiente procedimiento incluye ejemplos de cadenas de texto. Para mejorar la legibilidad, se han agregado saltos de línea a algunos de los ejemplos más largos. Al crear estas cadenas para su propio uso, debe omitir cualquier salto de línea.

**Para otorgar a roles y entidades principales federadas acceso a los recursos desde la Consola de administración de AWS**

1. Autentique al usuario en su sistema de autorización e identidad.

1. Obtenga credenciales de seguridad temporales para el usuario. Las credenciales temporales incluyen un ID de clave de acceso, una clave de acceso secreta y un token de seguridad. Para obtener más información sobre la creación de instancias de contenedor, consulte [Credenciales de seguridad temporales en IAM](id_credentials_temp.md).

   Para obtener credenciales temporales, puede llamar a la API [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) de AWS STS (recomendado) o a la API [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html). Para obtener más información sobre las diferencias entre estas operaciones API, consulte [Descripción de las opciones de la API para delegar de forma segura el acceso a su cuenta deAWS](https://aws.amazon.com/blogs/security/understanding-the-api-options-for-securely-delegating-access-to-your-aws-account) en el blog de seguridad de AWS.
**importante**  
Si utiliza la API [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html) para crear credenciales de seguridad temporales, debe especificar los permisos que dichas credenciales conceden al usuario que asume el rol. Para cualquiera de las operaciones API que empiezan por `AssumeRole*`, utilice un rol de IAM para asignar permisos. Para el resto de las operaciones API, el mecanismo varía según la API. Para obtener más información, consulte [Permisos para credenciales de seguridad temporales](id_credentials_temp_control-access.md). Además, si utiliza las operaciones `AssumeRole*` de la API, debe llamarlas como usuario de IAM con credenciales a largo plazo. De lo contrario, la llamada al punto de enlace de federación en el paso 3 produce un error.  


1. Después de obtener las credenciales de seguridad temporales, intégrelas en una cadena de sesión JSON para intercambiarlas por un token de inicio de sesión. El siguiente ejemplo muestra cómo codificar las credenciales. Sustituya el texto del marcador de posición con los valores adecuados de las credenciales que reciba en el paso anterior.

   ```
   {"sessionId":"*** temporary access key ID ***",
   "sessionKey":"*** temporary secret access key ***",
   "sessionToken":"*** session token ***"}
   ```

1. [Aplique el código URL](https://en.wikipedia.org/wiki/Percent-encoding) a la cadena de sesión del paso anterior. Dado que la información que está codificando es confidencial, recomendamos que evite utilizar un servicio web para esta codificación. En su lugar, utilice una función o característica instalada localmente en su conjunto de herramientas de desarrollo para codificar esta información de forma segura. Puede utilizar la función `urllib.quote_plus` en Python, la función `URLEncoder.encode` en Java o la función `CGI.escape` en Ruby. Consulte los ejemplos más adelante en este tema.

1. <a name="STSConsoleLink_manual_step5"></a>
**nota**  
AWS admite solicitudes POST aquí.

   Envíe su solicitud al punto de conexión de federación de AWS:

   `https://region-code.signin.aws.amazon.com/federation` 

   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). Opcionalmente, puede utilizar un punto de conexión de federación de inicio de sesión de AWS predeterminado:

   `https://signin.aws.amazon.com/federation` 

   La solicitud debe incluir los parámetros `Action` y `Session` y (opcionalmente) si ha utilizado una 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, un parámetro HTTP `SessionDuration`, tal como se muestra en el siguiente ejemplo.

   ```
   Action = getSigninToken
   SessionDuration = time in seconds
   Session = *** the URL encoded JSON string created in steps 3 & 4 ***
   ```
**nota**  
Las siguientes instrucciones de este paso solo funcionan con solicitudes GET.

   El parámetro HTTP `SessionDuration` especifica la duración de la sesión de consola. Esta es distinta de la duración de las credenciales temporales especificada mediante el parámetro `DurationSeconds`. Puede especificar un valor máximo de `SessionDuration` de 43 200 (12 horas). Si falta el parámetro `SessionDuration`, el valor predeterminado de la sesión será el correspondiente a la duración de las credenciales que ha recuperado de AWS STS en el paso 2 (que tienen el valor predeterminado de una hora). Consulte la [documentación de la API `AssumeRole`](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) para obtener más información sobre cómo especificar la duración mediante el parámetro `DurationSeconds`. La posibilidad de crear una sesión de consola con una duración superior a una hora es intrínseca a la operación `getSigninToken` del punto de enlace de federación.
**nota**  
Su `SessionDuration` no puede ser mayor o igual a la configuración de duración máxima de la sesión para el rol que está asumiendo. Por ejemplo, ha establecido en 5 horas la duración máxima de la sesión para el rol que desea asumir. Su parámetro `SessionDuration` puede ser de 16524 segundos o 4 horas y 59 segundos.
No utilice el parámetro HTTP `SessionDuration` si obtiene las credenciales temporales con `GetFederationToken`. La operación producirá un error.
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, las nuevas credenciales tienen una duración máxima de una hora. Cuando utiliza roles para [conceder permisos a las aplicaciones que se ejecutan en instancias EC2](id_roles_use_switch-role-ec2.md), esas aplicaciones no están sujetas a esta limitación.
No utilice el parámetro HTTP `SessionDuration` si obtiene las credenciales temporales mediante el encadenamiento de roles. La operación producirá un error.

   Cuando habilita sesiones de consola con una duración prolongada, aumenta el riesgo de exposición de credenciales. Para ayudarle a mitigar este riesgo, puede deshabilitar inmediatamente las sesiones de consola activas para cualquier rol eligiendo **Revoke Sessions** (Revocar sesiones) en la página de la consola de IAM **Role Summary** (Resumen de roles). Para obtener más información, consulte [Revocación de las credenciales de seguridad temporales de un rol de IAM](id_roles_use_revoke-sessions.md). 

    El siguiente es un ejemplo de lo que su solicitud podría parecer. Las líneas se ajustan aquí para facilitar su legibilidad, pero debe enviarla como una cadena de una sola línea.

   ```
   https://signin.aws.amazon.com/federation
   ?Action=getSigninToken
   &SessionDuration=1800
   &Session=%7B%22sessionId%22%3A+%22ASIAJUMHIZPTOKTBMK5A%22%2C+%22sessionKey%22
   %3A+%22LSD7LWI%2FL%2FN%2BgYpan5QFz0XUpc8s7HYjRsgcsrsm%22%2C+%22sessionToken%2
   2%3A+%22FQoDYXdzEBQaDLbj3VWv2u50NN%2F3yyLSASwYtWhPnGPMNmzZFfZsL0Qd3vtYHw5A5dW
   AjOsrkdPkghomIe3mJip5%2F0djDBbo7SmO%2FENDEiCdpsQKodTpleKA8xQq0CwFg6a69xdEBQT8
   FipATnLbKoyS4b%2FebhnsTUjZZQWp0wXXqFF7gSm%2FMe2tXe0jzsdP0O12obez9lijPSdF1k2b5
   PfGhiuyAR9aD5%2BubM0pY86fKex1qsytjvyTbZ9nXe6DvxVDcnCOhOGETJ7XFkSFdH0v%2FYR25C
   UAhJ3nXIkIbG7Ucv9cOEpCf%2Fg23ijRgILIBQ%3D%3D%22%7D
   ```

   La respuesta del punto de enlace de federación es un documento JSON con un valor de `SigninToken`. Tendrá un aspecto similar al siguiente ejemplo.

   ```
   {"SigninToken":"*** the SigninToken string ***"}
   ```

1. 
**nota**  
AWS admite solicitudes POST aquí.

   Por último, cree la URL que los usuarios pueden usar para acceder a la Consola de administración de AWS. La dirección URL es el mismo punto de enlace URL de federación que usó en [Step 5](#STSConsoleLink_manual_step5), además de los siguientes parámetros:

   ```
   ?Action = login
   &Issuer = *** the form-urlencoded URL for your internal sign-in page ***
   &Destination = *** the form-urlencoded URL to the desired AWS console page ***
   &SigninToken = *** the value of SigninToken received in the previous step ***
   ```
**nota**  
Las siguientes instrucciones de este paso solo funcionan con la API de GET.

   El siguiente ejemplo muestra lo que la dirección URL final podría parecer. La dirección URL es válida durante 15 minutos desde el momento en que se crea. Las credenciales de seguridad temporales y la sesión de consola integradas dentro de la dirección URL son válidas durante el periodo especificado en el parámetro HTTP `SessionDuration` al solicitarlas inicialmente. 

   ```
   https://signin.aws.amazon.com/federation
   ?Action=login
   &Issuer=https%3A%2F%2Fexample.com
   &Destination=https%3A%2F%2Fconsole.aws.amazon.com%2F
   &SigninToken=VCQgs5qZZt3Q6fn8Tr5EXAMPLEmLnwB7JjUc-SHwnUUWabcRdnWsi4DBn-dvC
   CZ85wrD0nmldUcZEXAMPLE-vXYH4Q__mleuF_W2BE5HYexbe9y4Of-kje53SsjNNecATfjIzpW1
   WibbnH6YcYRiBoffZBGExbEXAMPLE5aiKX4THWjQKC6gg6alHu6JFrnOJoK3dtP6I9a6hi6yPgm
   iOkPZMmNGmhsvVxetKzr8mx3pxhHbMEXAMPLETv1pij0rok3IyCR2YVcIjqwfWv32HU2Xlj471u
   3fU6uOfUComeKiqTGX974xzJOZbdmX_t_lLrhEXAMPLEDDIisSnyHGw2xaZZqudm4mo2uTDk9Pv
   9l5K0ZCqIgEXAMPLEcA6tgLPykEWGUyH6BdSC6166n4M4JkXIQgac7_7821YqixsNxZ6rsrpzwf
   nQoS14O7R0eJCCJ684EXAMPLEZRdBNnuLbUYpz2Iw3vIN0tQgOujwnwydPscM9F7foaEK3jwMkg
   Apeb1-6L_OB12MZhuFxx55555EXAMPLEhyETEd4ZulKPdXHkgl6T9ZkIlHz2Uy1RUTUhhUxNtSQ
   nWc5xkbBoEcXqpoSIeK7yhje9Vzhd61AEXAMPLElbWeouACEMG6-Vd3dAgFYd6i5FYoyFrZLWvm
   0LSG7RyYKeYN5VIzUk3YWQpyjP0RiT5KUrsUi-NEXAMPLExMOMdoODBEgKQsk-iu2ozh6r8bxwC
   RNhujg
   ```

## Ejemplo de código que utiliza Python
<a name="STSConsoleLink_programPython"></a>

En los siguientes ejemplos se muestra cómo utilizar Python para crear mediante programación una dirección URL que ofrezca a los usuarios acceso directo a la Consola de administración de AWS. Se incluyen dos ejemplos:
+ Federación mediante solicitudes GET para AWS
+ Federación mediante solicitudes POST para AWS

Ambos ejemplos usan la API [AWS SDK para Python (Boto3)](https://aws.amazon.com/tools/) y [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) para obtener credenciales de seguridad temporales.

No incluya `SessionDuration` si sus credenciales de `AssumeRoleSession` provienen del encadenamiento de roles. Si incluye`SessionDuration`, la operación producirá un error.

### Uso de solicitudes GET
<a name="post-api-py-example"></a>

```
import urllib, json, sys
import requests # 'pip install requests'
import boto3 # AWS SDK for Python (Boto3) 'pip install boto3'

# Step 1: Authenticate user in your own identity system.

# Step 2: Using the access keys for an IAM user in your Cuenta de AWS,
# call "AssumeRole" to get temporary access keys for the role or federated principal

# Note: Calls to AWS STS AssumeRole must be signed using the access key ID 
# and secret access key of an IAM user or using existing temporary credentials.
# The credentials can be in Amazon EC2 instance metadata, in environment variables, 
# or in a configuration file, and will be discovered automatically by the 
# client('sts') function. For more information, see the Python SDK docs:
# http://boto3.readthedocs.io/en/latest/reference/services/sts.html
# http://boto3.readthedocs.io/en/latest/reference/services/sts.html#STS.Client.assume_role
sts_connection = boto3.client('sts')

assumed_role_object = sts_connection.assume_role(
    RoleArn="arn:aws:iam::account-id:role/ROLE-NAME",
    RoleSessionName="AssumeRoleSession",
)

# Step 3: Format resulting temporary credentials into JSON
url_credentials = {}
url_credentials['sessionId'] = assumed_role_object.get('Credentials').get('AccessKeyId')
url_credentials['sessionKey'] = assumed_role_object.get('Credentials').get('SecretAccessKey')
url_credentials['sessionToken'] = assumed_role_object.get('Credentials').get('SessionToken')
json_string_with_temp_credentials = json.dumps(url_credentials)

# Step 4. Make request to AWS federation endpoint to get sign-in token. Construct the parameter string with
# the sign-in action request, a 12-hour session duration, and the JSON document with temporary credentials 
# as parameters.
request_parameters = "?Action=getSigninToken"
request_parameters += "&SessionDuration=43200"
if sys.version_info[0] < 3:
    def quote_plus_function(s):
        return urllib.quote_plus(s)
else:
    def quote_plus_function(s):
        return urllib.parse.quote_plus(s)
request_parameters += "&Session=" + quote_plus_function(json_string_with_temp_credentials)
request_url = "https://signin.aws.amazon.com/federation" + request_parameters
r = requests.get(request_url)
# Returns a JSON document with a single element named SigninToken.
signin_token = json.loads(r.text)

# Step 5: Create URL where users can use the sign-in token to sign in to 
# the console. This URL must be used within 15 minutes after the
# sign-in token was issued.
request_parameters = "?Action=login" 
request_parameters += "&Issuer=Example.org" 
request_parameters += "&Destination=" + quote_plus_function("https://console.aws.amazon.com/")
request_parameters += "&SigninToken=" + signin_token["SigninToken"]
request_url = "https://signin.aws.amazon.com/federation" + request_parameters

# Send final URL to stdout
print (request_url)
```

### Uso de solicitudes POST
<a name="get-api-py-example-1"></a>

```
import urllib, json, sys
import requests # 'pip install requests'
import boto3 # AWS SDK for Python (Boto3) 'pip install boto3'
import os
from selenium import webdriver # 'pip install selenium', 'brew install chromedriver'

# Step 1: Authenticate user in your own identity system.

# Step 2: Using the access keys for an IAM user in your ACuenta de AWS,
# call "AssumeRole" to get temporary access keys for the role or federated principal

# Note: Calls to AWS STS AssumeRole must be signed using the access key ID 
# and secret access key of an IAM user or using existing temporary credentials.
# The credentials can be in Amazon EC2 instance metadata, in environment variables, 

# or in a configuration file, and will be discovered automatically by the 
# client('sts') function. For more information, see the Python SDK docs:
# http://boto3.readthedocs.io/en/latest/reference/services/sts.html
# http://boto3.readthedocs.io/en/latest/reference/services/sts.html#STS.Client.assume_role
if sys.version_info[0] < 3:
    def quote_plus_function(s):
        return urllib.quote_plus(s)
else:
    def quote_plus_function(s):
        return urllib.parse.quote_plus(s)

sts_connection = boto3.client('sts')

assumed_role_object = sts_connection.assume_role(
    RoleArn="arn:aws:iam::account-id:role/ROLE-NAME",
    RoleSessionName="AssumeRoleDemoSession",
)

# Step 3: Format resulting temporary credentials into JSON
url_credentials = {}
url_credentials['sessionId'] = assumed_role_object.get('Credentials').get('AccessKeyId')
url_credentials['sessionKey'] = assumed_role_object.get('Credentials').get('SecretAccessKey')
url_credentials['sessionToken'] = assumed_role_object.get('Credentials').get('SessionToken')
json_string_with_temp_credentials = json.dumps(url_credentials)

# Step 4. Make request to AWS federation endpoint to get sign-in token. Construct the parameter string with
# the sign-in action request, a 12-hour session duration, and the JSON document with temporary credentials 
# as parameters.
request_parameters = {}
request_parameters['Action'] = 'getSigninToken'
request_parameters['SessionDuration'] = '43200'
request_parameters['Session'] = json_string_with_temp_credentials

request_url = "https://signin.aws.amazon.com/federation"
r = requests.post( request_url, data=request_parameters)

# Returns a JSON document with a single element named SigninToken.
signin_token = json.loads(r.text)

# Step 5: Create a POST request where users can use the sign-in token to sign in to 
# the console. The POST request must be made within 15 minutes after the
# sign-in token was issued.
request_parameters = {}
request_parameters['Action'] = 'login'
request_parameters['Issuer']='Example.org'
request_parameters['Destination'] = 'https://console.aws.amazon.com/'
request_parameters['SigninToken'] =signin_token['SigninToken']

jsrequest = '''
var form = document.createElement('form');
form.method = 'POST';
form.action = '{request_url}';
request_parameters = {request_parameters}
for (var param in request_parameters) {{
    if (request_parameters.hasOwnProperty(param)) {{
        const hiddenField = document.createElement('input');
        hiddenField.type = 'hidden';
        hiddenField.name = param;
        hiddenField.value = request_parameters[param];
        form.appendChild(hiddenField);
    }}
}}
document.body.appendChild(form);
form.submit();
'''.format(request_url=request_url, request_parameters=request_parameters)

driver = webdriver.Chrome()
driver.execute_script(jsrequest)
input("Press Enter to close the browser window...")
```

## Ejemplo de código que utiliza Java
<a name="STSConsoleLink_programJava"></a>

El siguiente ejemplo muestra cómo utilizar Java para crear de forma programada una dirección URL que ofrezca a los usuarios acceso directo a la Consola de administración de AWS. El siguiente fragmento de código usa [AWS SDK para Java](https://aws.amazon.com/documentation/sdkforjava/).

```
import java.net.URLEncoder;
import java.net.URL;
import java.net.URLConnection;
import java.io.BufferedReader;
import java.io.InputStreamReader;
// Available at http://www.json.org/java/index.html
import org.json.JSONObject;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClient;
import com.amazonaws.services.securitytoken.model.Credentials;
import com.amazonaws.services.securitytoken.model.GetFederationTokenRequest;
import com.amazonaws.services.securitytoken.model.GetFederationTokenResult;


/* Calls to AWS STS API operations must be signed using the access key ID 
   and secret access key of an IAM user or using existing temporary 
   credentials. The credentials should not be embedded in code. For 
   this example, the code looks for the credentials in a 
   standard configuration file.
*/
AWSCredentials credentials = 
  new PropertiesCredentials(
         AwsConsoleApp.class.getResourceAsStream("AwsCredentials.properties"));

AWSSecurityTokenServiceClient stsClient = 
  new AWSSecurityTokenServiceClient(credentials);

GetFederationTokenRequest getFederationTokenRequest = 
  new GetFederationTokenRequest();
getFederationTokenRequest.setDurationSeconds(1800);
getFederationTokenRequest.setName("UserName");

// A sample policy for accessing Amazon Simple Notification Service (Amazon SNS) in the console.

String policy = "{\"Version\":\"2012-10-17\",		 	 	 \"Statement\":[{\"Action\":\"sns:*\"," +
  "\"Effect\":\"Allow\",\"Resource\":\"*\"}]}";

getFederationTokenRequest.setPolicy(policy);

GetFederationTokenResult federationTokenResult = 
  stsClient.getFederationToken(getFederationTokenRequest);

Credentials federatedCredentials = federationTokenResult.getCredentials();

// The issuer parameter specifies your internal sign-in
// page, for example https://mysignin.internal.mycompany.com/.
// The console parameter specifies the URL to the destination console of the
// AWS Management Console. This example goes to Amazon SNS. 
// The signin parameter is the URL to send the request to.

String issuerURL = "https://mysignin.internal.mycompany.com/";
String consoleURL = "https://console.aws.amazon.com/sns";
String signInURL = "https://signin.aws.amazon.com/federation";
  
// Create the sign-in token using temporary credentials,
// including the access key ID,  secret access key, and session token.
String sessionJson = String.format(
  "{\"%1$s\":\"%2$s\",\"%3$s\":\"%4$s\",\"%5$s\":\"%6$s\"}",
  "sessionId", federatedCredentials.getAccessKeyId(),
  "sessionKey", federatedCredentials.getSecretAccessKey(),
  "sessionToken", federatedCredentials.getSessionToken());
              
// Construct the sign-in request with the request sign-in token action, a
// 12-hour console session duration, and the JSON document with temporary 
// credentials as parameters.

String getSigninTokenURL = signInURL + 
                           "?Action=getSigninToken" +
                           "&DurationSeconds=43200" + 
                           "&SessionType=json&Session=" + 
                           URLEncoder.encode(sessionJson,"UTF-8");

URL url = new URL(getSigninTokenURL);

// Send the request to the AWS federation endpoint to get the sign-in token
URLConnection conn = url.openConnection ();

BufferedReader bufferReader = new BufferedReader(new 
  InputStreamReader(conn.getInputStream()));  
String returnContent = bufferReader.readLine();

String signinToken = new JSONObject(returnContent).getString("SigninToken");

String signinTokenParameter = "&SigninToken=" + URLEncoder.encode(signinToken,"UTF-8");

// The issuer parameter is optional, but recommended. Use it to direct users
// to your sign-in page when their session expires.

String issuerParameter = "&Issuer=" + URLEncoder.encode(issuerURL, "UTF-8");

// Finally, present the completed URL for the AWS console session to the user

String destinationParameter = "&Destination=" + URLEncoder.encode(consoleURL,"UTF-8");
String loginURL = signInURL + "?Action=login" +
                     signinTokenParameter + issuerParameter + destinationParameter;
```

## Ejemplo que muestra cómo crear la dirección URL (Ruby)
<a name="STSConsoleLink_programRuby"></a>

El siguiente ejemplo muestra cómo utilizar Ruby para crear de forma programada una dirección URL que ofrezca a los usuarios acceso directo a la Consola de administración de AWS. Este fragmento de código usa [AWS SDK para Ruby](https://aws.amazon.com/documentation/sdkforruby/). 

```
require 'rubygems'
require 'json'
require 'open-uri'
require 'cgi'
require 'aws-sdk'

# Create a new STS instance
# 
# Note: Calls to AWS STS API operations must be signed using an access key ID 
# and secret access key. The credentials can be in EC2 instance metadata 
# or in environment variables and will be automatically discovered by
# the default credentials provider in the AWS Ruby SDK. 
sts = Aws::STS::Client.new()

# The following call creates a temporary session that returns 
# temporary security credentials and a session token.
# The policy grants permissions to work
# in the AWS SNS console.

session = sts.get_federation_token({
  duration_seconds: 1800,
  name: "UserName",
  policy: "{\"Version\":\"2012-10-17\",		 	 	 \"Statement\":{\"Effect\":\"Allow\",\"Action\":\"sns:*\",\"Resource\":\"*\"}}",
})

# The issuer value is the URL where users are directed (such as
# to your internal sign-in page) when their session expires.
#
# The console value specifies the URL to the destination console.
# This example goes to the Amazon SNS console.
#
# The sign-in value is the URL of the AWS STS federation endpoint.
issuer_url = "https://mysignin.internal.mycompany.com/"
console_url = "https://console.aws.amazon.com/sns"
signin_url = "https://signin.aws.amazon.com/federation"

# Create a block of JSON that contains the temporary credentials
# (including the access key ID, secret access key, and session token).
session_json = {
  :sessionId => session.credentials[:access_key_id],
  :sessionKey => session.credentials[:secret_access_key],
  :sessionToken => session.credentials[:session_token]
}.to_json

# Call the federation endpoint, passing the parameters
# created earlier and the session information as a JSON block. 
# The request returns a sign-in token that's valid for 15 minutes.
# Signing in to the console with the token creates a session 
# that is valid for 12 hours.
get_signin_token_url = signin_url + 
                       "?Action=getSigninToken" + 
                       "&SessionType=json&Session=" + 
                       CGI.escape(session_json)

returned_content = URI.parse(get_signin_token_url).read

# Extract the sign-in token from the information returned
# by the federation endpoint.
signin_token = JSON.parse(returned_content)['SigninToken']
signin_token_param = "&SigninToken=" + CGI.escape(signin_token)

# Create the URL to give to the user, which includes the
# sign-in token and the URL of the console to open.
# The "issuer" parameter is optional but recommended.
issuer_param = "&Issuer=" + CGI.escape(issuer_url)
destination_param = "&Destination=" + CGI.escape(console_url)
login_url = signin_url + "?Action=login" + signin_token_param + 
  issuer_param + destination_param
```