Activation de l'accès à la AWS console par un courtier d'identité personnalisé - AWS Identity and Access Management
Exemple de code utilisant les opérations d'API Query IAMExemple de code utilisant PythonExemple de code utilisant JavaExemple montrant comment créer l'URL (Ruby)

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Activation de l'accès à la AWS console par un courtier d'identité personnalisé

Vous pouvez écrire et exécuter du code afin de créer une URL qui permet aux utilisateurs qui se connectent au réseau de votre organisation d'accéder en toute sécurité à AWS Management Console. L'URL inclut un jeton de connexion que vous obtenez AWS et qui authentifie l'utilisateur. AWS La session de console obtenue peut inclure un AccessKeyId distinct en raison de la fédération. Pour suivre l'utilisation des clés d'accès pour la connexion à la fédération par le biais d' CloudTrail événements connexes, consultez la section Événements Journalisation des appels IAM et AWS STS API avec AWS CloudTrail de AWS Management Console connexion.

Note

Si votre organisation utilise un fournisseur d'identité (IdP) qui est compatible avec SAML, vous pouvez configurer l'accès à la console sans écrire de code. Cela fonctionne avec des fournisseurs tels que Microsoft Active Directory Federation Services ou Shibboleth (open source). Pour plus de détails, consultez Activation de l'accès des utilisateurs fédérés SAML 2.0 à la AWS Management Console.

Pour permettre aux utilisateurs de votre organisation d'accéder au AWS Management Console, vous pouvez créer un courtier d'identité personnalisé qui exécute les étapes suivantes :

  1. Vérifier que l'utilisateur est authentifié par votre système d'identité local.

  2. Appelez les opérations AWS Security Token Service (AWS STS) AssumeRole(recommandé) ou GetFederationTokenAPI pour obtenir des informations d'identification de sécurité temporaires pour l'utilisateur. Pour connaître les différentes méthodes que vous pouvez utiliser pour endosser un rôle, consultez Utilisation de rôles IAM. Pour savoir comment transmettre des balises de session facultatives lorsque vous obtenez vos informations d'identification de sécurité, veuillez consulter Transmission des balises de session AWS STS.

    • Si vous utilisez l'une des opérations d'API AssumeRole* pour obtenir les informations d'identification de sécurité temporaires pour un rôle, vous pouvez inclure le paramètre DurationSeconds dans votre appel. Ce paramètre spécifie la durée de la session de votre rôle, entre 900 secondes (15 minutes) et la durée de session maximale pour le rôle. Lorsque vous utilisez DurationSeconds dans une opération AssumeRole*, vous devez l'appeler en tant qu'utilisateur IAM avec des informations d'identification à long terme. Sinon, l'appel au point de terminaison de fédération de l'étape 3 échoue. Pour savoir comment afficher ou modifier la valeur maximale pour un rôle, consultez Affichage du paramètre de durée de session maximale pour un rôle.

    • Si vous utilisez l'opération d'API GetFederationToken pour obtenir les informations d'identification, vous pouvez inclure le paramètre DurationSeconds dans votre appel. Ce paramètre spécifie la durée de votre session de rôle. La valeur peut être comprise entre 900 secondes (15 minutes) et 129 600 secondes (36 heures). Vous pouvez effectuer cet appel d'API uniquement en utilisant les informations de AWS sécurité à long terme d'un utilisateur IAM. Vous pouvez également effectuer ces appels à l'aide Utilisateur racine d'un compte AWS d'informations d'identification, mais nous ne le recommandons pas. Si vous effectuez cet appel en tant qu'utilisateur racine, la session par défaut dure une heure. Ou vous pouvez spécifier une session de 900 secondes (15 minutes) à 3 600 secondes (une heure).

  3. Appelez le point de terminaison de la AWS fédération et fournissez les informations d'identification de sécurité temporaires pour demander un jeton de connexion.

  4. Créer une URL incluant le jeton pour la console :

    • Si vous utilisez l'une des opérations d'API AssumeRole* dans votre URL, vous pouvez inclure le paramètre HTTP SessionDuration. Ce paramètre spécifie la durée de la session de la console, de 900 secondes (15 minutes) à 43 200 secondes (12 heures).

    • Si vous utilisez l'opération d'API GetFederationToken dans votre URL, vous pouvez inclure le paramètre DurationSeconds. Ce paramètre spécifie la durée de la session de console fédérée. La valeur peut être comprise entre 900 secondes (15 minutes) et 129 600 secondes (36 heures).

      Note

      • N'utilisez pas le paramètre HTTP SessionDuration si vous avez obtenu les informations d'identification avec GetFederationToken. L'opération échouerait.

      • L'utilisation des informations d'identification pour qu'un rôle endosse un rôle différent est appelée chaînes de rôles. Lorsque vous utilisez la création de chaînes de rôles, vos nouvelles informations d'identification sont limitées à une durée maximale d'une heure. Lorsque vous utilisez des rôles pour accorder des autorisations aux applications qui s'exécutent sur des instances EC2, ces applications ne sont pas soumises à cette limitation.

  5. Donner l'URL à l'utilisateur ou appeler l'URL pour le compte de l'utilisateur.

L'URL fournie par le point de terminaison de fédération est valide pendant 15 minutes à compter de sa création. Cette durée est différente de celle (en secondes) de la session des informations d'identification de sécurité temporaires associées à l'URL. Ces informations d'identification sont valides pendant la durée spécifiée lors de leur création et ce, à compter du moment où elles sont créées.

Important

L'URL donne accès à vos AWS ressources via les autorisations AWS Management Console si vous avez activé les autorisations dans les informations d'identification de sécurité temporaires associées. Pour cette raison, vous devez considérer l'URL comme un secret. Nous vous recommandons de retourner l'URL via une redirection sécurisée, par exemple, en utilisant un code de statut de réponse HTTP 302 via une connexion SSL. Pour plus d'informations sur le code de statut de réponse HTTP 302, consultez RFC 2616, section 10.3.3.

Pour effectuer ces tâches, vous pouvez utiliser l'API Query HTTPS pour AWS Identity and Access Management (IAM) et AWS Security Token Service (AWS STS). Vous pouvez également utiliser des langages de programmation tels que Java, Ruby ou C#, avec le kit SDK AWS approprié. Chacune de ces méthodes est décrite dans les rubriques suivantes.

Vous pouvez créer une URL qui donne à vos utilisateurs fédérés un accès direct au AWS Management Console. Cette tâche utilise les API de requête IAM et AWS STS HTTPS. Pour de plus amples informations sur les demandes de requête, veuillez consulter Envoi de demandes de requête.

Note

La procédure suivante contient des exemples de chaînes de texte. Pour faciliter la lecture, des sauts de ligne ont été ajoutés aux exemples les plus longs. Lorsque vous créez ces chaînes pour votre propre utilisation, il convient d'omettre les sauts de ligne.

Pour donner à un utilisateur fédéré l'accès à vos ressources depuis le AWS Management Console

  1. Authentifiez l'utilisateur dans votre système d'identité et d'autorisation.

  2. Obtenez des informations d'identification de sécurité temporaires pour l'utilisateur. Les informations d'identification temporaires incluent un ID de clé d'accès, une clé d'accès secrète et un jeton (token) de session. Pour plus d'informations sur la création d'informations d'identification temporaires, consultez Informations d'identification de sécurité temporaires dans IAM.

    Pour obtenir des informations d'identification temporaires, vous devez appeler l' AWS STS AssumeRoleAPI (recommandé) ou l'GetFederationTokenAPI. Pour plus d'informations sur les différences entre ces opérations d'API, consultez la section Comprendre les options d'API pour déléguer l'accès à votre AWS compte en toute sécurité dans le blog sur la AWS sécurité.

    Important

    Lorsque vous utilisez l'GetFederationTokenAPI pour créer des informations d'identification de sécurité temporaires, vous devez spécifier les autorisations que les informations d'identification accordent à l'utilisateur qui assume le rôle. Dès lors que les opérations d'API commencent par AssumeRole*, vous utilisez un rôle IAM pour accorder les autorisations. Pour les autres opérations d'API, le mécanisme varie en fonction de l'API. Pour en savoir plus, consultez Contrôle des autorisations affectées aux informations d'identification de sécurité temporaires. De plus, si vous utilisez les opérations d'API AssumeRole*, vous devez les appeler en tant qu'utilisateur IAM avec des informations d'identification à long terme. Sinon, l'appel au point de terminaison de fédération de l'étape 3 échoue.

  3. Une fois que vous avez obtenu les informations d'identification de sécurité temporaires, insérez-les dans une chaîne de session JSON pour les échanger contre un jeton de connexion. L'exemple suivant montre comment encoder les informations d'identification. Vous remplacez le texte de l'espace réservé par les valeurs appropriées dans les informations d'identification reçues à l'étape précédente.

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

  4. Encodez par URL la chaîne de session de l'étape précédente. Dans la mesure où les informations que vous encodez sont sensibles, nous vous recommandons de ne pas utiliser de service web pour cette opération. Utilisez, à la place, une fonction installée en local ou une fonctionnalité de votre boîte à outils de développement pour encoder cette information de manière sécurisée. Vous pouvez utiliser la fonction urllib.quote_plus dans Python, la fonction URLEncoder.encode dans Java ou la fonction CGI.escape dans Ruby. Consultez les exemples dans la suite de cette rubrique.

  5. Note

    AWS prend en charge les requêtes POST ici.

    Enfin, créez l'URL que vos utilisateurs fédérés utiliseront pour accéder à AWS Management Console. L'URL est la même URL de point de terminaison de fédération que celle que vous avez utilisée dans Étape 5, à laquelle sont ajoutés les paramètres suivants :

    ?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 ***
    Note

    Les instructions suivantes de cette étape ne fonctionnent qu'avec l'API GET.

    L'exemple suivant montre comment se présentera l'URL finale. L'URL est valide pendant 15 minutes à partir du moment où elle est créée. Les informations d'identification de sécurité temporaires et la session de console intégrées dans l'URL sont valides pendant la durée spécifiée dans le paramètre HTTP SessionDuration lors de leur demande initiale. 

    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

L'exemple suivant montre comment utiliser Python pour créer par programmation une URL qui donne aux utilisateurs fédérés un accès direct à AWS Management Console. Voici deux exemples :

  • Fédérez via des requêtes GET pour AWS

  • Fédérez via des requêtes POST pour AWS

Les deux exemples utilisent l'AssumeRoleAPI AWS SDK for Python (Boto3)and pour obtenir des informations d'identification de sécurité temporaires.

Utiliser des requêtes GET

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 Compte AWS,
# call "AssumeRole" to get temporary access keys for the federated user

# 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)

Utiliser des requêtes POST

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 ACompte AWS,
# call "AssumeRole" to get temporary access keys for the federated user

# 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);

L'exemple suivant montre comment utiliser Java pour créer par programmation une URL qui donne aux utilisateurs fédérés un accès direct à AWS Management Console. L'extrait de code suivant utilise le kit SDK AWS pour Java.

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;

L'exemple suivant montre comment utiliser Ruby pour créer par programmation une URL qui donne aux utilisateurs fédérés un accès direct à AWS Management Console. Cet extrait de code utilise le kit SDK AWS pour Ruby. 

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