Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Benutzerdefinierten Identity Broker-Zugriff auf die AWS Konsole aktivieren
<a name="id_roles_providers_enable-console-custom-url"></a>

Sie können Code schreiben und ausführen, um eine URL zu erstellen, über die Benutzer, die sich beim Netzwerk Ihrer Organisation anmelden, sicheren Zugriff auf die AWS-Managementkonsole haben. Die URL enthält ein Anmeldetoken, das Sie erhalten AWS und das den Benutzer authentifiziert. AWS Die daraus resultierende Konsolensitzung kann aufgrund eines Verbunds eine eindeutige `AccessKeyId` enthalten. [Informationen zur Verwendung des Zugriffsschlüssels für die Verbundanmeldung anhand verwandter CloudTrail Ereignisse finden Sie unter [Protokollierung von IAM- und AWS STS API-Aufrufen mit AWS CloudTrail](cloudtrail-integration.md) und AWS-Managementkonsole unter Anmeldeereignisse.](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-aws-console-sign-in-events.html) 

**Anmerkung**  
Wenn Ihre Organisation einen Identitätsanbieter (IdP) verwendet, der mit SAML kompatibel ist, können Sie den Zugriff auf die Konsole einrichten, ohne dass Code geschrieben werden muss. Dies funktioniert mit Anbietern wie Microsoft Active Directory Federation Services oder Open-Source-Shibboleth. Details hierzu finden Sie unter [Aktivieren des Zugriffs von SAML 2.0-Verbundprinzipalen auf AWS-Managementkonsole](id_roles_providers_enable-console-saml.md). 

Um den Benutzern Ihrer Organisation den Zugriff auf zu ermöglichen AWS-Managementkonsole, können Sie einen benutzerdefinierten *Identity Broker* erstellen, der die folgenden Schritte ausführt:

1. Überprüfen Sie, ob der Benutzer von Ihrem lokalen Identitätssystem authentifiziert ist.

1. Rufen Sie die Operationen AWS -Security-Token-Service (AWS STS) [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)(empfohlen) oder [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html)API auf, um temporäre Sicherheitsanmeldeinformationen für den Benutzer abzurufen. Weitere Informationen zu den unterschiedlichen Methoden, die Sie zum Übernehmen einer Rolle verwenden können, finden Sie unter [Methoden, um eine Rolle zu übernehmen](id_roles_manage-assume.md). Weitere Informationen zur Übergabe optionaler Sitzungs-Tags bei Erhalt Ihrer Sicherheitsanmeldeinformationen finden Sie unter [Sitzungs-Tags übergeben AWS STS](id_session-tags.md).
   + Wenn Sie eine der `AssumeRole*` API-Operationen verwenden, um die temporären Sicherheitsanmeldeinformationen für eine Rolle zu erhalten, können Sie den Parameter `DurationSeconds` in Ihren Aufruf einschließen. Dieser Parameter gibt die Dauer Ihrer Rollensitzung von 900 Sekunden (15 Minuten) bis zur maximalen Sitzungsdauer für die Rolle an. Wenn Sie `DurationSeconds` in einer `AssumeRole*`-Operation verwenden, müssen Sie das als IAM-Benutzer mit langfristigen Anmeldeinformationen aufrufen. Andernfalls schlägt der Aufruf des Verbund-Endpunkts in Schritt 3 fällt. Weitere Informationen dazu, wie Sie den maximalen Wert für eine Rolle anzeigen oder ändern können, finden Sie unter [Aktualisieren der maximalen Sitzungsdauer für eine Rolle](id_roles_update-role-settings.md#id_roles_update-session-duration).
   + Wenn Sie die `GetFederationToken`-API-Operation verwenden, um die Anmeldeinformationen zu erhalten, können Sie den `DurationSeconds`-Parameter in Ihre Aufruf aufnehmen. Dieser Parameter gibt die Dauer Ihrer Rollensitzung an. Der Wert kann im Bereich zwischen 900 Sekunden (15 Minuten) und 129 600 Sekunden (36 Stunden) liegen. Sie können diesen API-Aufruf nur mit den langfristigen AWS Sicherheitsanmeldedaten eines IAM-Benutzers ausführen. Sie können diese Aufrufe auch mit Root-Benutzer des AWS-Kontos Anmeldeinformationen tätigen, wir empfehlen dies jedoch nicht. Wenn Sie diesen Aufruf als Stammbenutzer tätigen, dauert die Standardsitzung eine Stunde. Sie können auch eine Sitzung zwischen 900 Sekunden (15 Minuten) und 3 600 Sekunden (eine Stunde) festlegen. 

1. Rufen Sie den AWS Verbundendpunkt auf und geben Sie die temporären Sicherheitsanmeldedaten ein, um ein Anmeldetoken anzufordern.

1. Erstellen Sie eine URL für die Konsole, die das Token enthält:
   + Wenn Sie eine der `AssumeRole*`-API-Operationen in Ihrer URL verwenden, können Sie den `SessionDuration`-HTTP-Parameter einschließen. Dieser Parameter gibt die Dauer der Konsolensitzung an, von 900 Sekunden (15 Minuten) bis 43 200 Sekunden (12 Stunden).
   + Wenn Sie die `GetFederationToken`-API-Operation in Ihrer URL verwenden, können Sie den `DurationSeconds`-Parameter einschließen. Dieser Parameter gibt die Dauer der verbundenen Konsolensitzung an. Der Wert kann im Bereich zwischen 900 Sekunden (15 Minuten) und 129 600 Sekunden (36 Stunden) liegen. 
**Anmerkung**  
Ihr `SessionDuration` darf nicht größer oder gleich der Einstellung für die maximale Sitzungsdauer für die von Ihnen übernommene Rolle sein. Sie haben beispielsweise die maximale Sitzungsdauer für die Rolle, die Sie übernehmen möchten, auf 5 Stunden festgelegt. Ihr `SessionDuration`-Parameter kann 16 524 Sekunden oder 4 Stunden und 59 Sekunden betragen.
Verwenden Sie nicht den HTTP-Parameter `SessionDuration`, wenn Sie temporäre Anmeldeinformationen mit `GetFederationToken` abrufen. Der Vorgang schlägt fehl.
Die Verwendung der Anmeldeinformationen für eine Rolle zur Übernahme einer anderen Rolle wird als [*Verketten von Rollen*](id_roles.md#iam-term-role-chaining) bezeichnet. Wenn Sie die Verkettung von Rollen verwenden, sind Ihre neuen Anmeldeinformationen auf eine maximale Dauer von einer Stunde begrenzt. Wenn Sie Rollen verwenden, um [Berechtigungen für Anwendungen zu erteilen, die auf EC2-Instances ausgeführt werden](id_roles_use_switch-role-ec2.md), unterliegen diese Anwendungen nicht dieser Einschränkung.
Verwenden Sie nicht den HTTP-Parameter `SessionDuration`, wenn Sie temporäre Anmeldeinformationen über Rollenverkettung abrufen. Der Vorgang schlägt fehl.

1. Geben Sie die URL an den Benutzer weiter oder rufen Sie sie im Namen des Benutzers auf.

Die vom Verbund-Endpunkt bereitgestellte URL ist 15 Minuten lang gültig, nachdem sie erstellt wurde. Dies unterscheidet sich von der Dauer (in Sekunden) der Sitzung mit temporären Sicherheitsanmeldeinformationen, die mit der URL verbunden ist. Diese Anmeldeinformationen sind für die Dauer gültig, die Sie beim Erstellen angegeben haben, beginnend ab dem Zeitpunkt der Erstellung.

**Wichtig**  
Die URL gewährt Zugriff auf Ihre AWS Ressourcen über die, AWS-Managementkonsole sofern Sie in den zugehörigen temporären Sicherheitsanmeldedaten die entsprechenden Berechtigungen aktiviert haben. Aus diesem Grund sollten Sie die URL geheim halten. Wir empfehlen, die URL über eine sichere Umleitung zurückzugeben, z. B. mittels eines HTTP-Antwortstatuscodes 302 über eine SSL-Verbindung. Weitere Informationen über den HTTP-Antwortstatuscode 302 finden Sie unter [RFC 2616, section 10.3.3](https://datatracker.ietf.org/doc/html/rfc2616#section-10.3.3).

Um diese Aufgaben zu erledigen, können Sie die [HTTPS Query API für AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/APIReference/) und die [AWS -Security-Token-Service (AWS STS) verwenden](https://docs.aws.amazon.com/STS/latest/APIReference/). Sie können aber auch Programmiersprachen, wie Java, Ruby oder C\$1, zusammen mit dem entsprechenden [AWS -SDK](https://aws.amazon.com/tools/), verwenden. Jede dieser Methoden wird in den folgenden Themen beschrieben.

**Topics**
+ [Beispielcode unter Verwendung von IAM-Abfrage-API-Operationen](#STSConsoleLink_manual)
+ [Beispielcode unter Verwendung von Python](#STSConsoleLink_programPython)
+ [Beispielcode unter Verwendung von Java](#STSConsoleLink_programJava)
+ [Beispiel für das Erstellen einer URL (Ruby)](#STSConsoleLink_programRuby)

## Beispielcode unter Verwendung von IAM-Abfrage-API-Operationen
<a name="STSConsoleLink_manual"></a>

Sie können eine URL erstellen, die Rollen und Verbundprinzipalen direkten Zugriff auf die AWS-Managementkonsole gewährt. Diese Aufgabe verwendet die IAM- und AWS STS HTTPS-Abfrage-API. Weitere Informationen zum Erstellen von Abfrageanforderungen finden Sie unter [Erstellen von Abfrageanforderungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html).

**Anmerkung**  
Das folgende Verfahren enthält Beispiele für Textzeichenfolgen. Zur Erhöhung der Lesbarkeit wurden Zeilenumbrüche zu einigen der längeren Beispiele hinzugefügt. Wenn Sie diese Zeichenfolgen zur eigenen Verwendung erstellen, sollten Sie keine Zeilenumbrüche setzen.

**Um Rollen und Verbundprinzipalen Zugriff auf Ihre Ressourcen zu gewähren AWS-Managementkonsole**

1. Authentifizieren Sie den Benutzer in Ihrem Identitäts- und Autorisierungssystem.

1. Rufen Sie temporäre Sicherheitsanmeldeinformationen für den Benutzer ab. Die temporären Anmeldeinformationen bestehen aus einer Zugriffsschlüssel-ID, einem geheimen Zugriffsschlüssel und einem Sitzungs-Token. Weitere Informationen über das Erstellen temporärer Anmeldeinformationen finden Sie unter [Temporäre IAM Sicherheitsanmeldeinformationen](id_credentials_temp.md).

   Um temporäre Anmeldeinformationen zu erhalten, rufen Sie entweder die AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API (empfohlen) oder die [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html)API auf. Weitere Informationen zu den Unterschieden zwischen diesen API-Vorgängen finden Sie im AWS Sicherheitsblog unter [Grundlegendes zu den API-Optionen für die sichere Delegierung des Zugriffs auf Ihr AWS Konto](https://aws.amazon.com/blogs/security/understanding-the-api-options-for-securely-delegating-access-to-your-aws-account).
**Wichtig**  
Wenn Sie die [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html)API verwenden, um temporäre Sicherheitsanmeldedaten zu erstellen, müssen Sie die Berechtigungen angeben, die die Anmeldeinformationen dem Benutzer gewähren, der die Rolle übernimmt. Für alle API-Operationen, die mit `AssumeRole*` beginnen, verwenden Sie eine IAM-Rolle, um Berechtigungen zuzuweisen. Für die anderen API-Operationen hängt der Mechanismus von der API ab. Weitere Details finden Sie unter [Berechtigungen für temporäre Sicherheits-Anmeldeinformationen](id_credentials_temp_control-access.md). Wenn Sie die `AssumeRole*`-API-Operationen verwenden, müssen Sie sie außerdem als IAM-Benutzer mit langfristigen Anmeldeinformationen aufrufen. Andernfalls schlägt der Aufruf des Verbund-Endpunkts in Schritt 3 fällt.  


1. Nachdem Sie die temporären Sicherheitsanmeldeinformationen abgerufen haben, integrieren Sie sie in eine JSON-Sitzungs-Zeichenfolge, um sie geben ein Anmelde-Token zu tauschen. Im folgenden Beispiel wird gezeigt, wie Sie die Anmeldeinformationen codieren. Ersetzen Sie den Platzhaltertext durch die entsprechenden Werte aus den Anmeldeinformationen, die Sie im vorherigen Schritt erhalten haben.

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

1. Führen Sie eine [URL-Codierung](https://en.wikipedia.org/wiki/Percent-encoding) der Sitzungs-Zeichenfolge aus dem vorherigen Schritt durch. Da die Informationen, die Sie codieren, sensibel sind, raten wir davon ab, einen Webservice für diese Codierung zu verwenden. Verwenden Sie stattdessen ein lokal installiertes Feature in Ihrem Entwicklungs-Toolkits, um diese Informationen sicher zu codieren. Sie können die Funktion `urllib.quote_plus` in Python, die Funktion `URLEncoder.encode`in Java oder die Funktion `CGI.escape` in Ruby verwenden. Beispiele finden Sie an späterer Stelle in diesem Thema.

1. <a name="STSConsoleLink_manual_step5"></a>
**Anmerkung**  
AWS unterstützt hier POST-Anfragen.

   Senden Sie Ihre Anfrage an den AWS Föderationsendpunkt:

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

   Eine Liste möglicher *region-code* Werte finden Sie in der Spalte **Region** unter [AWS Anmelde-Endpunkte](https://docs.aws.amazon.com/general/latest/gr/signin-service.html). Sie können optional den standardmäßigen AWS Anmeldendpunkt für den Verbund verwenden:

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

   Die Anforderung muss die `Action`- und `Session`-Parameter enthalten und (optional) – wenn Sie eine [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)-API-Operation verwendet haben – einen `SessionDuration`-HTTP-Parameter, wie im folgenden Beispiel gezeigt.

   ```
   Action = getSigninToken
   SessionDuration = time in seconds
   Session = *** the URL encoded JSON string created in steps 3 & 4 ***
   ```
**Anmerkung**  
Die folgenden Anweisungen in diesem Schritt funktionieren nur mithilfe von GET-Anforderungen.

   Der `SessionDuration`-HTTP-Parameter gibt die Dauer der Konsolensitzung an. Dies ist von der Dauer der temporären Anmeldeinformationen, die Sie mit dem `DurationSeconds`-Parameter angeben, unabhängig. Sie können für `SessionDuration` einen maximalen Wert von 43200 (12 Stunden) festlegen. Wenn der `SessionDuration` Parameter fehlt, wird für die Sitzung standardmäßig die Dauer der Anmeldeinformationen verwendet, die Sie AWS STS in Schritt 2 abgerufen haben (standardmäßig eine Stunde). Details zur Festlegung der Dauer unter Verwendung des Parameters `DurationSeconds` finden Sie in der [-Dokumentation für die `AssumeRole`-API](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html). Die Möglichkeit zum Erstellen einer Konsolensitzung, die länger als eine Stunde dauert, ist eine intrinsische `getSigninToken`-Operation des Verbund-Endpunkts.
**Anmerkung**  
Ihr `SessionDuration` darf nicht größer oder gleich der Einstellung für die maximale Sitzungsdauer für die von Ihnen übernommene Rolle sein. Sie haben beispielsweise die maximale Sitzungsdauer für die Rolle, die Sie übernehmen möchten, auf 5 Stunden festgelegt. Ihr `SessionDuration`-Parameter kann 16 524 Sekunden oder 4 Stunden und 59 Sekunden betragen.
Verwenden Sie nicht den HTTP-Parameter `SessionDuration`, wenn Sie temporäre Anmeldeinformationen mit `GetFederationToken` abrufen. Der Vorgang schlägt fehl.
Die Verwendung der Anmeldeinformationen für eine Rolle zur Übernahme einer anderen Rolle wird als [*Verketten von Rollen*](id_roles.md#iam-term-role-chaining) bezeichnet. Wenn Sie die Verkettung von Rollen verwenden, sind Ihre neuen Anmeldeinformationen auf eine maximale Dauer von einer Stunde begrenzt. Wenn Sie Rollen verwenden, um [Berechtigungen für Anwendungen zu erteilen, die auf EC2-Instances ausgeführt werden](id_roles_use_switch-role-ec2.md), unterliegen diese Anwendungen nicht dieser Einschränkung.
Verwenden Sie nicht den HTTP-Parameter `SessionDuration`, wenn Sie temporäre Anmeldeinformationen über Rollenverkettung abrufen. Der Vorgang schlägt fehl.

   Wenn Sie Konsolensitzungen mit einer erweiterten Dauer aktivieren, erhöhen Sie das Risiko einer Aufdeckung der Anmeldeinformationen. Um dieses Risiko zu minimieren, können Sie die aktiven Konsolensitzungen für jede Rolle direkt deaktivieren, indem Sie **Revoke Sessions** (Sitzungen aufheben) auf der Seite **Role Summary** (Rollenübersicht) in der IAM-Konsole wählen. Weitere Informationen finden Sie unter [Temporäre Sicherheitsanmeldeinformationen der IAM-Rolle widerrufen](id_roles_use_revoke-sessions.md). 

    Das folgende Beispiel zeigt, wie die Anforderung aussehen kann. Die Zeilen sind hier für bessere Lesbarkeit gebrochen, die Zeichenfolge sollte aber in einer Zeile übermittelt werden.

   ```
   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
   ```

   Die Antwort des Verbund-Endpunkts ist ein JSON-Dokument mit einem `SigninToken`-Wert. Er sollte wie im folgenden Beispiel aussehen.

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

1. 
**Anmerkung**  
AWS unterstützt hier POST-Anfragen.

   Schließlich erstellen Sie die URL, die Ihre Benutzer für den Zugriff auf die AWS-Managementkonsole verwenden können. Die URL ist derselbe Verbund-URL-Endpunkt, den Sie in [Step 5](#STSConsoleLink_manual_step5) verwendet haben, plus die folgenden Parameter:

   ```
   ?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 ***
   ```
**Anmerkung**  
Die folgenden Anweisungen in diesem Schritt funktionieren nur mithilfe von GET-API.

   Das folgende Beispiel zeigt, wie die endgültige URL aussehen könnte. Die URL ist ab dem Zeitpunkt, zu dem sie erstellt wurde, 15 Minuten lang gültig. Die temporären Sicherheitsanmeldeinformationen und die in der URL eingebettete Konsolensitzung ist für die Dauer gültig, die Sie bei der ersten Anforderung im `SessionDuration`-HTTP-Parameter angegeben haben. 

   ```
   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
   ```

## Beispielcode unter Verwendung von Python
<a name="STSConsoleLink_programPython"></a>

Das folgende Beispiel zeigt, wie Sie mit Python programmgesteuert eine URL erstellen können, die Benutzern direkten Zugriff auf die AWS-Managementkonsole gewährt. Es gibt zwei Beispiele:
+ Föderieren Sie über GET-Anfragen an AWS
+ Verbinden Sie sich über POST-Anfragen an AWS

Beide Beispiele verwenden die [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API [AWS SDK für Python (Boto3)](https://aws.amazon.com/tools/)und, um temporäre Sicherheitsanmeldedaten abzurufen.

Geben Sie `SessionDuration` nicht an, wenn Ihre `AssumeRoleSession`-Anmeldeinformationen aus einer Rollenverkettung stammen. Wenn Sie `SessionDuration` angeben, schlägt der Vorgang fehl.

### GET-Anforderungen verwenden
<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 AWS-Konto,
# 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)
```

### GET-Anforderungen verwenden
<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 A AWS-Konto,
# 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...")
```

## Beispielcode unter Verwendung von Java
<a name="STSConsoleLink_programJava"></a>

Das folgende Beispiel zeigt, wie Sie mit Java programmgesteuert eine URL erstellen können, die Benutzern direkten Zugriff auf die AWS-Managementkonsole gewährt. Das folgende Codefragment verwendet das [AWS SDK for 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;
```

## Beispiel für das Erstellen einer URL (Ruby)
<a name="STSConsoleLink_programRuby"></a>

Das folgende Beispiel zeigt, wie Sie mit Ruby programmgesteuert eine URL erstellen können, die Benutzern direkten Zugriff auf die AWS-Managementkonsole gewährt. Dieses Codefragment verwendet das [AWS SDK for 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
```