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.

# IAM-Rollen
<a name="id_roles"></a>

Eine IAM-*Rolle* ist eine IAM-Identität, die Sie in Ihrem Konto mit bestimmten Berechtigungen erstellen können. Eine IAM-Rolle ist einem IAM-Benutzer ähnlich, weil es sich um eine AWS -Identität mit Berechtigungsrichtlinien handelt, die festlegen, welche Aktionen die Identität in AWS ausführen kann und welche nicht. Eine Rolle ist jedoch nicht einer einzigen Person zugeordnet, sondern kann von allen Personen angenommen werden, die diese Rolle benötigen. Einer Rolle sind außerdem keine standardmäßigen, langfristigen Anmeldeinformationen (Passwörter oder Zugriffsschlüssel) zugeordnet. Wenn Sie eine Rolle übernehmen, erhalten Sie stattdessen temporäre Anmeldeinformationen für Ihre Rollensitzung.

Sie können Rollen verwenden, um den Zugriff an Benutzer, Anwendungen oder Dienste zu delegieren, die normalerweise keinen Zugriff auf Ihre AWS Ressourcen haben. Möglicherweise möchten Sie Benutzern in Ihrem AWS Konto Zugriff auf Ressourcen gewähren, über die sie normalerweise nicht verfügen, oder Benutzern in einem Konto AWS-Konto Zugriff auf Ressourcen in einem anderen Konto gewähren. Oder Sie möchten einer mobilen App die Nutzung von AWS Ressourcen ermöglichen, aber keine AWS Schlüssel in die App einbetten (wo sie schwierig zu aktualisieren sein können und Benutzer sie möglicherweise extrahieren können). Manchmal möchten Sie Benutzern AWS Zugriff gewähren, für die bereits Identitäten außerhalb von definiert wurden AWS, z. B. in Ihrem Unternehmensverzeichnis. Oder Sie können auch Drittanbietern Zugriff auf Ihr Konto gewähren, sodass sie eine Prüfung Ihrer Ressourcen ausführen können.

In diesen Szenarien können Sie den Zugriff auf AWS Ressourcen mithilfe einer *IAM-Rolle* delegieren. Dieser Abschnitt bietet eine Einführung in Rollen und in die verschiedenen Verwendungsmöglichkeiten, wann und wie Sie unter den Methoden auswählen können und wie Sie Rollen erstellen, verwalten, annehmen und löschen bzw. zu diesen wechseln können.

**Anmerkung**  
Wenn Sie Ihre Rollen zum ersten Mal erstellen AWS-Konto, werden standardmäßig keine Rollen erstellt. Wenn Sie Ihrem Konto Services hinzufügen, können sie zur Unterstützung ihrer Anwendungsfälle serviceverknüpfte Rollen hinzufügen.  
 Eine serviceverknüpfte Rolle ist eine Art von Servicerolle, die mit einer AWS-Service verknüpft ist. Der Service kann die Rolle übernehmen, um eine Aktion in Ihrem Namen auszuführen. Dienstbezogene Rollen werden in Ihrem Dienst angezeigt AWS-Konto und gehören dem Dienst. Ein IAM-Administrator kann die Berechtigungen für Service-verknüpfte Rollen anzeigen, aber nicht bearbeiten.   
Bevor Sie die serviceverknüpften Rollen löschen können, müssen Sie zunächst die zugehörigen Ressourcen löschen. Dies schützt Ihre -Ressourcen, da Sie nicht versehentlich die Berechtigung für den Zugriff auf die Ressourcen entfernen können.  
Informationen darüber, welche Services die Verwendung von serviceverknüpften Rollen unterstützen, finden Sie unter [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md). Suchen Sie nach den Services, für die **Ja** in der Spalte **Serviceverknüpfte Rolle** angegeben ist. Wählen Sie über einen Link **Ja** aus, um die Dokumentation zu einer serviceverknüpften Rolle für diesen Service anzuzeigen.

**Topics**
+ [Erstellen eines IAM-Benutzers (anstatt eine Rolle)](#id_which-to-choose)
+ [Rollenbegriffe und -konzepte](#id_roles_terms-and-concepts)
+ [Weitere Ressourcen](#id_roles_additional-resources)
+ [Das Confused-Deputy-Problem](confused-deputy.md)
+ [Gängige Szenarien für IAM-Rollen](id_roles_common-scenarios.md)
+ [Erstellung einer IAM-Rolle](id_roles_create.md)
+ [IAM-Rollen-Verwaltung](id_roles_manage.md)
+ [Methoden, um eine Rolle zu übernehmen](id_roles_manage-assume.md)

## Erstellen eines IAM-Benutzers (anstatt eine Rolle)
<a name="id_which-to-choose"></a>

Wir empfehlen, IAM-Benutzer nur für Anwendungsfälle zu verwenden, die durch den Identitätsverbund nicht unterstützt werden. Einige der Anwendungsfälle umfassen Folgendes:
+ **Workloads, die IAM-Rollen nicht verwenden können** – Sie könnten einen Workload von einem Speicherort ausführen, der auf AWS zugreifen muss. In einigen Situationen können Sie IAM-Rollen nicht verwenden, um temporäre Anmeldeinformationen bereitzustellen, z. B. für WordPress Plugins. Verwenden Sie in diesen Situationen langfristige IAM-Benutzerzugriffsschlüssel für diesen Workload, um sich bei AWS zu authentifizieren.
+ ** AWS Drittanbieter-Clients** — Wenn Sie Tools verwenden, die den Zugriff mit IAM Identity Center nicht unterstützen, z. B. AWS Drittanbieter-Clients oder Anbieter, die nicht auf gehostet werden AWS, verwenden Sie langfristige IAM-Benutzerzugriffsschlüssel.
+ **AWS CodeCommit Zugriff** — Wenn Sie Ihren Code CodeCommit zum Speichern verwenden, können Sie einen IAM-Benutzer mit SSH-Schlüsseln oder dienstspezifischen Anmeldeinformationen verwenden, um sich bei Ihren Repositorys CodeCommit zu authentifizieren. Wir empfehlen Ihnen, dies zusätzlich zu einem Benutzer im IAM Identity Center für die normale Authentifizierung zu verwenden. Benutzer in IAM Identity Center sind die Personen in Ihrer Belegschaft, die Zugriff auf Ihre oder Ihre AWS-Konten Cloud-Anwendungen benötigen. Um Benutzern Zugriff auf Ihre CodeCommit Repositorys zu gewähren, ohne IAM-Benutzer zu konfigurieren, können Sie das Hilfsprogramm konfigurieren. **git-remote-codecommit** Weitere Informationen zu IAM und CodeCommit finden Sie unter. [IAM-Anmeldeinformationen für CodeCommit: Git-Anmeldeinformationen, SSH-Schlüssel und AWS Zugriffsschlüssel](id_credentials_ssh-keys.md) Weitere Informationen zur Konfiguration des **git-remote-codecommit** Dienstprogramms finden Sie im *AWS CodeCommit Benutzerhandbuch* unter [Herstellen einer Verbindung zu AWS CodeCommit Repositorys mit wechselnden Anmeldeinformationen](https://docs.aws.amazon.com/codecommit/latest/userguide/temporary-access.html#temporary-access-configure-credentials).
+ **Zugriff auf Amazon Keyspaces (für Apache Cassandra)** – In einer Situation, in der Sie Benutzer im IAM Identity Center nicht verwenden können, z. B. zu Testzwecken für die Cassandra-Kompatibilität, können Sie einen IAM-Benutzer mit dienstspezifischen Anmeldeinformationen verwenden, um sich bei Amazon Keyspaces zu authentifizieren. Benutzer in IAM Identity Center sind die Personen in Ihrer Belegschaft, die Zugriff auf Ihre AWS-Konten oder Ihre Cloud-Anwendungen benötigen. Sie können auch mithilfe temporärer Anmeldeinformationen eine Verbindung zu Amazon Keyspaces herstellen. Weitere Informationen finden Sie unter [Verwendung temporärer Anmeldeinformationen für die Verbindung zu Amazon Keyspaces mithilfe einer IAM-Rolle und des SigV4-Plugins](https://docs.aws.amazon.com/keyspaces/latest/devguide/access.credentials.html#temporary.credentials.IAM) im *Amazon Keyspaces (für Apache Cassandra)-Entwicklerhandbuch*.
+ **Notfallzugriff** – In einer Situation, in der Sie keinen Zugriff auf Ihren Identitätsanbieter haben und in Ihrem AWS-Konto Maßnahmen ergreifen müssen. Die Einrichtung von IAM-Benutzern für den Notfallzugriff kann Teil Ihres Resilienzplans sein. Wir empfehlen Ihnen, die Anmeldeinformationen für den Notfallbenutzer genau zu kontrollieren und sie mit Multi-Faktor-Authentifizierung (MFA) zu sichern.

## Rollenbegriffe und -konzepte
<a name="id_roles_terms-and-concepts"></a>

Im Folgenden finden Sie einige grundlegende Begriffe, die Ihnen bei den ersten Schritten mit Rollen helfen.

****Rolle****  
Eine IAM-Identität, die Sie in Ihrem Konto erstellen können und die über bestimmte Berechtigungen verfügt. Es gibt gewisse Ähnlichkeiten zwischen einer IAM-Rolle und einem IAM-Benutzer. Sowohl Rollen als auch Benutzer sind AWS -Identitäten mit Berechtigungsrichtlinien, die bestimmen, was die Identität in AWS tun kann und was nicht. Eine Rolle ist jedoch nicht einer einzigen Person zugeordnet, sondern kann von allen Personen angenommen werden, die diese Rolle benötigen. Einer Rolle sind außerdem keine standardmäßigen, langfristigen Anmeldeinformationen (Passwörter oder Zugriffsschlüssel) zugeordnet. Wenn Sie eine Rolle übernehmen, erhalten Sie stattdessen temporäre Anmeldeinformationen für Ihre Rollensitzung.  
Rollen können von folgenden Personen übernommen werden:  
+ Ein IAM-Benutzer in demselben AWS-Konto oder einem anderen AWS-Konto
+ IAM-Rollen im selben Konto
+ Dienstprinzipale zur Verwendung mit AWS Diensten und Funktionen wie:
  + Dienste, mit denen Sie Code auf Rechendiensten ausführen können, wie Amazon EC2 oder AWS Lambda
  + Features, die in Ihrem Namen Aktionen an Ihren Ressourcen ausführen, wie z. B. die Amazon-S3-Objektreplikation
  + Services, die temporäre Sicherheitsanmeldedaten für Ihre Anwendungen bereitstellen, die außerhalb von ausgeführt werden AWS, wie z. B. IAM Roles Anywhere oder Amazon ECS Anywhere
+ Ein externer Benutzer, der von einem externen Identitätsanbieter (IdP) authentifiziert wurde, der mit SAML 2.0 oder OpenID Connect kompatibel ist

****AWS Servicerolle****  
 Eine Servicerolle ist eine [IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html), die ein Service annimmt, um Aktionen in Ihrem Namen auszuführen. Ein IAM-Administrator kann eine Servicerolle innerhalb von IAM erstellen, ändern und löschen. Weitere Informationen finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen AWS-Service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) im *IAM-Benutzerhandbuch*. 

****AWS Servicebezogene Rolle****  
 Eine dienstbezogene Rolle ist eine Art von Servicerolle, die mit einer verknüpft ist. AWS-Service Der Service kann die Rolle übernehmen, um eine Aktion in Ihrem Namen auszuführen. Dienstbezogene Rollen werden in Ihrem Dienst angezeigt AWS-Konto und gehören dem Dienst. Ein IAM-Administrator kann die Berechtigungen für Service-verknüpfte Rollen anzeigen, aber nicht bearbeiten.   
Wenn Sie einen Service bereits verwenden, wenn er mit der Unterstützung serviceverknüpfter Rollen beginnt, erhalten Sie möglicherweise eine E-Mail zur Benachrichtigung über die neue Rolle in Ihrem Konto. In diesem Fall erstellt der Service die serviceverknüpfte Rolle automatisch in Ihrem Konto. Sie müssen keine Aktion zum Unterstützen dieser Rolle durchführen und Sie sollten sie nicht manuell löschen. Weitere Informationen finden Sie unter [In meinem AWS Konto wurde eine neue Rolle angezeigt](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared).
Informationen darüber, welche Services die Verwendung von serviceverknüpften Rollen unterstützen, finden Sie unter [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md). Suchen Sie nach den Services, für die **Ja** in der Spalte **Serviceverknüpfte Rolle** angegeben ist. Wählen Sie über einen Link **Ja** aus, um die Dokumentation zu einer serviceverknüpften Rolle für diesen Service anzuzeigen. Weitere Informationen finden Sie unter [Erstellen einer serviceverknüpften Rolle](id_roles_create-service-linked-role.md).

****Verketten von Rollen****  
Das Verketten von Rollen tritt auf, wenn Sie eine Rolle verwenden, um eine zweite Rolle anzunehmen. Sie können die Rollenverkettung über die oder die AWS-Managementkonsole API durchführen, indem Sie die AWS CLI Rollen wechseln. Zum Beispiel: `RoleA` verfügt über die Berechtigung `RoleB` anzunehmen. Sie können Benutzer1 die Übernahme ermöglichen, `RoleA` indem Sie ihre langfristigen Benutzeranmeldedaten im AssumeRole API-Vorgang verwenden. Diese gibt die kurzfristigen Anmeldeinformationen von `RoleA` zurück. Für das Verketten von Rollen können Sie die kurzfristigen Anmeldeinformationen von `RoleA` verwenden, um User1 zu ermöglichen `RoleB` anzunehmen.  
Wenn Sie eine Rolle übernehmen, können Sie ein Sitzungs-Tag übergeben und dieses als transitiv festlegen. Transitive Sitzungs-Tags werden an alle nachfolgenden Sitzungen in einer Rollenkette übergeben. Weitere Informationen zu Sitzungs-Tags finden Sie unter [Sitzungs-Tags übergeben AWS STS](id_session-tags.md).  
Durch die Rollenverkettung wird Ihre AWS-Managementkonsole Rollensitzung AWS CLI oder Ihre AWS API-Rollensitzung auf maximal eine Stunde begrenzt. Das gilt unabhängig von der für einzelne Rollen konfigurierten maximalen Sitzungsdauer. Wenn Sie den [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API-Vorgang verwenden, um eine Rolle anzunehmen, können Sie die Dauer Ihrer Rollensitzung mit dem `DurationSeconds` Parameter angeben. Sie können einen Parameterwert von bis zu 43200 Sekunden (12 Stunden) angeben, abhängig von der Einstellung [maximale Sitzungsdauer](id_roles_update-role-settings.md#id_roles_update-session-duration) für Ihre Rolle. Wenn Sie eine Rolle durch Verkettung übernehmen und für den Parameter `DurationSeconds` einen Wert größer als eine Stunde angeben, schlägt die Operation jedoch fehl.  
Hinweise zum Wechseln zu einer Rolle in der AWS-Managementkonsole finden Sie unter[Von einem Benutzer zu einer IAM-Rolle wechseln (Konsole)](id_roles_use_switch-role-console.md).

****Delegierung****  
Die Erteilung von Berechtigungen für jemanden, um den Zugriff auf Ressourcen zu gewähren, die Sie kontrollieren. Die Delegierung beinhaltet die Einrichtung einer Vertrauensstellung zwischen zwei Konten. Das erste Konto ist Eigentümer der Ressource (das vertrauensvolle Konto). Das zweite Konto enthält die Benutzer, die auf die Ressource zugreifen müssen (das vertrauenswürdige Konto). Die vertrauenswürdigen und vertrauensvollen Konten können Folgende sein:  
+ Das gleiche Konto.
+ Separate Konten, die beide von Ihrer Organisation kontrolliert werden.
+ Zwei Konten im Besitz von unterschiedlichen Organisationen.
Zum Delegieren einer Berechtigung für den Zugriff auf eine Ressource [erstellen Sie eine IAM-Rolle](id_roles_create_for-user.md) im vertrauenden Konto, der zwei Richtlinien angefügt sind. Die *Berechtigungsrichtlinie* erteilt dem Benutzer der Rolle die erforderlichen Berechtigungen zum Ausführen der vorgesehenen Aufgaben auf der Ressource. Die *Vertrauensrichtlinie* gibt an, welche vertrauenswürdigen Kontomitglieder die Rolle übernehmen dürfen.  
Wenn Sie eine Vertrauensrichtlinie erstellen, können Sie keinen Platzhalter (\$1) als Teil eines ARN im Prinzipalelement angeben. Die Vertrauensrichtlinie ist an die Rolle im vertrauenden Konto angefügt und eine Hälfte der Berechtigungen. Die andere Hälfte ist eine Berechtigungsrichtlinie, die dem Benutzer im vertrauenswürdigen Konto angefügt ist und [zulässt, dass ein Benutzer zur Rolle wechselt bzw. diese übernimmt](id_roles_use_permissions-to-switch.md). Ein Benutzer, der eine Rolle übernimmt, gibt vorübergehend seine eigenen Berechtigungen auf und übernimmt stattdessen die Berechtigungen der Rolle. Wenn der Benutzer die Rolle beendet oder nicht mehr verwendet, werden die ursprünglichen Benutzerberechtigungen wiederhergestellt. Ein zusätzlicher Parameter namens [external ID](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id) kann helfen, die sichere Verwendung von Rollen zwischen Konten sicherzustellen, die nicht von der gleichen Organisation kontrolliert werden.

****Vertrauensrichtlinie****  
Ein [JSON-Richtliniendokument](reference_policies_grammar.md), in dem Sie die Auftraggeber definieren, denen Sie es *anvertrauen*, die Rolle zu übernehmen. Eine Rollenvertrauensrichtlinie ist eine erforderliche [ressourcenbasierte Richtlinie](access_policies.md#policies_resource-based) die einer Rolle in IAM angefügt ist. Zu den [Auftraggeber](reference_policies_elements_principal.md), die Sie in der Vertrauensrichtlinie angeben können, gehören Benutzer, Rollen, Konten und Services. Weitere Informationen finden Sie unter [Verwendung von Vertrauensrichtlinien in IAM-Rollen](https://aws.amazon.com/blogs//security/how-to-use-trust-policies-with-iam-roles/) im *AWS -Blog zum Thema Sicherheit*.

****Rolle für kontoübergreifenden Zugriff****  
Eine Rolle gewährt Ressourcen in einem Konto Zugriff auf einen vertrauenswürdigen Auftraggeber in einem anderen Konto. Rollen stellen die primäre Möglichkeit dar, um kontoübergreifendem Zugriff zu gewähren. Bei einigen AWS Diensten können Sie jedoch eine Richtlinie direkt an eine Ressource anhängen (anstatt eine Rolle als Proxy zu verwenden). Diese werden als ressourcenbasierte Richtlinien bezeichnet und Sie können sie verwenden, um anderen Benutzern AWS-Konto Zugriff auf die Ressource zu gewähren. Einige dieser Ressourcen umfassen Amazon-S3-Buckets (Simple Storage Service), Amazon Glacier Tresore, Amazon-SNS-Themen (Simple Notification Service) und Amazon-SQS-Warteschlangen (Simple Queue Service). Weitere Informationen darüber, welche Services ressourcenbasierte Richtlinien unterstützen, finden Sie unter [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md). Weitere Informationen zu ressourcenbasierten Richtlinien finden Sie unter [Kontoübergreifender Zugriff auf Ressourcen in IAM](access_policies-cross-account-resource-access.md).

## Weitere Ressourcen
<a name="id_roles_additional-resources"></a>

Mithilfe der folgenden Ressourcen erfahren Sie mehr über die IAM-Terminologie im Zusammenhang mit IAM-Rollen.
+ **Principals** sind Entitäten AWS , die Aktionen ausführen und auf Ressourcen zugreifen können. Ein Principal kann ein Root-Benutzer des AWS-Kontos, ein IAM-Benutzer oder eine Rolle sein. Ein Principal, der die Identität eines AWS Dienstes repräsentiert, ist ein [Dienstprinzipal](reference_policies_elements_principal.md#principal-services). Verwenden Sie das Prinzipal-Element in Vertrauensrichtlinien für Rollen, um die Prinzipale zu definieren, denen Sie die Übernahme der Rolle anvertrauen.

   Weitere Informationen und Beispiele zu Prinzipale, denen Sie die Übernahme einer Rolle erlauben können, finden Sie unter [AWS JSON-Richtlinienelemente: Principal](reference_policies_elements_principal.md). 
+ Ein **Identitätsverbund** schafft eine Vertrauensbeziehung zwischen einem externen Identitätsanbieter und AWS. Sie können Ihren vorhandenen Anbieter für OpenID Connect (OIDC) oder Security Assertion Markup Language (SAML) 2.0 verwenden, um zu verwalten, wer auf AWS -Ressourcen zugreifen kann. Wenn Sie OIDC und SAML 2.0 verwenden, um eine Vertrauensbeziehung zwischen diesen externen Identitätsanbietern und zu konfigurieren AWS , wird dem Benutzer eine IAM-Rolle zugewiesen. Der Benutzer erhält auch temporäre Anmeldeinformationen, die ihm den Zugriff auf Ihre AWS -Ressourcen ermöglichen.

  Weitere Informationen zu Verbundprinzipalen finden Sie unter [Identitätsanbieter und Verbund zu AWS](id_roles_providers.md).
+ **Verbundprinzipale** sind vorhandene Identitäten aus Ihrem Unternehmensbenutzerverzeichnis oder einem Directory Service OIDC-Anbieter. AWS [weist einem Verbundprinzipal eine Rolle zu, wenn der Zugriff über einen Identitätsanbieter angefordert wird.](id_roles_providers.md)

  Weitere Informationen zu den SAML- und OIDC-Verbundprinzipalen finden Sie unter [Verbundbenutzersitzungen und Rollen](introduction_access-management.md#intro-access-roles).
+ **Berechtigungsrichtlinien** sind identitätsbasierte Richtlinien, die definieren, welche Aktionen und Ressourcen die Rolle verwenden kann. Das Dokument wird entsprechend den Regeln der IAM-Richtliniensprache geschrieben. 

  Weitere Informationen finden Sie unter [IAM-JSON-Richtlinienreferenz](reference_policies.md).
+ **Berechtigungsgrenzen** sind ein erweitertes Feature, bei dem Sie Richtlinien verwenden, um die maximalen Berechtigungen einzuschränken, die eine identitätsbasierte Richtlinie einer Rolle gewähren kann. Sie können eine Berechtigungsgrenze nicht auf eine servicegebundene Rolle anwenden.

  Weitere Informationen finden Sie unter [Berechtigungsgrenzen für IAM-Entitäten](access_policies_boundaries.md).

# Das Confused-Deputy-Problem
<a name="confused-deputy"></a>

Das Problem des verwirrten Stellvertreters ist ein Sicherheitsproblem, bei dem eine Entität, die keine Berechtigung zur Durchführung einer Aktion hat, eine privilegiertere Entität zur Durchführung der Aktion zwingen kann. Um dies zu verhindern, AWS stellt Tools bereit, die Ihnen helfen, Ihr Konto zu schützen, wenn Sie Dritten (bekannt als *kontoübergreifender* Zugriff) oder anderen AWS Diensten (bekannt als *dienstübergreifender* Zugriff) Zugriff auf Ressourcen in Ihrem Konto gewähren.

Manchmal müssen Sie möglicherweise einer dritten Partei Zugriff auf Ihre AWS Ressourcen gewähren (Delegiertenzugriff). Sie entscheiden sich beispielsweise dafür, ein Drittanbieter namens Example Corp mit der Überwachung Ihrer Kosten AWS-Konto und der Kostenoptimierung zu beauftragen. Um Ihre täglichen Ausgaben verfolgen zu können, muss Example Corp auf Ihre AWS Ressourcen zugreifen. Example Corp überwacht zudem viele weitere AWS-Konten anderer Kunden. Sie können eine IAM-Rolle verwenden, um eine vertrauenswürdige Beziehung zwischen Ihrem Konto AWS-Konto und dem Example Corp-Konto aufzubauen. Ein wichtiger Faktor hierbei ist die *externe ID*, eine optionale Kennung, mit der Sie in Vertrauensrichtlinien von IAM-Rollen festlegen können, wer die Rolle übernehmen kann. Die Hauptfunktion des externen Ausweises besteht darin, das Problem des verwirrten Stellvertreters zu lösen und zu verhindern.

Einige AWS Dienste (Aufrufdienste) verwenden ihren AWS Dienstprinzipal, um auf AWS Ressourcen anderer AWS Dienste (sogenannte Dienste) zuzugreifen. Bei einigen dieser Dienstinteraktionen können Sie Anrufdienste so konfigurieren, dass sie mit den Ressourcen eines aufgerufenen Dienstes in einem anderen Dienst kommunizieren AWS-Konto. Ein Beispiel hierfür ist die Konfiguration AWS CloudTrail , um in einen zentralen Amazon S3 S3-Bucket zu schreiben, der sich in einem anderen befindet AWS-Konto. Dem aufrufenden Dienst CloudTrail wird mithilfe der Richtlinie des S3-Buckets Zugriff auf Ihren S3-Bucket gewährt, indem eine Allow-Anweisung für hinzugefügt wird`cloudtrail.amazonaws.com`.

Wenn ein AWS Dienstprinzipal von einem aufrufenden Dienst auf eine Ressource von einem aufgerufenen Dienst zugreift, autorisiert die Ressourcenrichtlinie des aufgerufenen Dienstes nur den AWS Dienstprinzipal und nicht den Akteur, der den aufrufenden Dienst konfiguriert hat. Beispielsweise könnte ein S3-Bucket, der dem CloudTrail Service Principal ohne Bedingungen vertraut, CloudTrail Logs von dem empfangen AWS-Konten , den ein vertrauenswürdiger Administrator konfiguriert hat, aber auch CloudTrail Logs von einem nicht autorisierten Akteur in seinem Bucket AWS-Konto, sofern dieser den Namen des S3-Buckets kennt.

Das Problem des verwirrten Stellvertreters entsteht, wenn ein Akteur das Vertrauen des Dienstprinzipals eines AWS Dienstes nutzt, um Zugriff auf Ressourcen zu erhalten, auf die er eigentlich keinen Zugriff haben sollte.

## Vermeidung des Problems des verwirrten Stellvertreters (kontoübergreifend)
<a name="mitigate-confused-deputy"></a>

In der nachfolgenden Abbildung wird das verwirrte Stellvertreter-Problem dargestellt.

![\[Beschreibung eines Problems des verwirrten Stellvertreters\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/confuseddeputyproblem2.png)


In diesem Szenario wird von Folgendem ausgegangen:
+ **AWS 1** ist dein AWS-Konto.
+ **AWS 1: ExampleRole** ist eine Rolle in Ihrem Konto. Über die Vertrauensrichtlinie dieser Rolle wird das AWS -Konto von Example Corp angegeben und kann somit die Rolle übernehmen.

Es passiert Folgendes:

1. Wenn Sie beginnen, den Service von Example Corp zu nutzen, geben Sie den ARN **AWS 1: ExampleRole** an Example Corp.

1. Example Corp verwendet diesen Rollen-ARN, um temporäre Sicherheitsanmeldeinformationen für den Zugriff auf Ressourcen in Ihrem zu erhalten AWS-Konto. Sie machen Example Corp also zu Ihrem "Stellvertreter", der in Ihrem Namen handeln darf.

1. Ein anderer AWS Kunde beginnt ebenfalls, den Service von Example Corp zu nutzen, und dieser Kunde stellt auch den ARN **AWS 1 zur Verfügung: ExampleRole** für Example Corp zur Nutzung. Vermutlich hat der andere Kunde die **AWS 1:** gelernt oder erratenExampleRole, was kein Geheimnis ist.

1. Wenn der andere Kunde Example Corp bittet, auf AWS Ressourcen in seinem Konto zuzugreifen (was es vorgibt), verwendet Example Corp **AWS 1:**, ExampleRole um auf Ressourcen in Ihrem Konto zuzugreifen.

So kann der andere Kunde unautorisiert Zugriff auf Ihre Ressourcen erlangen. Da der Kunde Example Corp dahingehend manipuliert hat, unwissentlich auf Ihre Ressourcen zuzugreifen, ist Beispielunternehmen nun ein "verwirrter Stellvertreter".

Example Corp vermeidet dieses Problem zum Beispiel, indem sie verlangt, in der Vertrauensrichtlinie der Rolle eine `ExternalId`-Bedingungsprüfung aufzunehmen. Example Corp generiert zum Beispiel einen einzigartigen`ExternalId`-Wert für jeden Kunden und verwendet diesen Wert in seiner Anforderung, um die Rolle zu übernehmen. Der `ExternalId`-Wert muss unter den Kunden von Example Corp eindeutig sein und von Example Corp kontrolliert werden, nicht von seinen Kunden. Deshalb erhalten Sie diese ID auch von Example Corp und können sie nicht selbst erstellen. Dadurch wird verhindert, dass Example Corp ein verwirrter Stellvertreter ist und Zugriff auf die AWS Ressourcen eines anderen Kontos gewährt.

Stellen Sie sich in unserem Szenario vor, dass Ihre eindeutige ID beim Example Corp 12345 lautet und die ID des anderen Kunden 67890. Die IDs sind für dieses Szenario vereinfacht. Im Allgemeinen sind diese Identifikatoren. GUIDs Angenommen, diese IDs sind innerhalb des Kundenstamms von Example Corp eindeutig und es handelt sich um sinnvolle externe ID-Werte. 

Example Corp teilt Ihnen den externen ID-Wert 12345 mit. Sie fügen nun ein `Condition`-Element zur Vertrauensrichtlinie der Rolle hinzu, dessen [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-sts)-Wert 12345 lauten muss. Beispiel:

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

****  

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

------

Das Condition-Element in dieser Richtlinie ermöglicht es Example Corp, die Rolle nur zu übernehmen, wenn der AssumeRole API-Aufruf den externen ID-Wert 12345 enthält. Example Corp stellt sicher, dass jedes Mal, wenn es eine Rolle im Namen eines Kunden übernimmt, immer den externen ID-Wert dieses Kunden in den AssumeRole Anruf mit einbezieht. Selbst wenn ein anderer Kunde Example Corp Ihren ARN zur Verfügung stellt, kann er nicht kontrollieren, welche externe ID Example Corp in seiner Anfrage an Example Corp angibt AWS. So wird verhindert, dass nicht autorisierte Kunden Zugriff auf Ihre Ressourcen erhalten.

Das folgende Diagramm verdeutlicht dieses Konzept.

![\[Vermeiden des Problems des verwirrten Stellvertreters\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/confuseddeputymitigation2.png)


1. Wenn Sie den Service von Example Corp nutzen, geben Sie wie bisher den ARN **AWS 1: ExampleRole** an Example Corp. weiter.

1.  Wenn Example Corp diesen Rollen-ARN verwendet, um die Rolle **AWS 1:** anzunehmenExampleRole, nimmt Example Corp Ihre externe ID (12345) in den AssumeRole API-Aufruf auf. Die externe ID entspricht der Vertrauensrichtlinie der Rolle, sodass der AssumeRole API-Aufruf erfolgreich ist und Example Corp temporäre Sicherheitsanmeldedaten für den Zugriff auf Ressourcen in Ihrem erhält. AWS-Konto

1. Ein anderer AWS Kunde beginnt ebenfalls, den Service von Example Corp zu nutzen, und wie zuvor stellt dieser Kunde auch den ARN von **AWS 1 zur Verfügung: ExampleRole** für Example Corp zur Nutzung. 

1. Aber dieses Mal, wenn Example Corp versucht, die Rolle **AWS 1:** anzunehmenExampleRole, gibt es die externe ID an, die dem anderen Kunden zugeordnet ist (67890). Der andere Kunde hat keinen Einfluss darauf. Example Corp gibt dies an, da die Anforderung zur Verwendung der Rolle von dem anderen Kunden stammte und 67890 somit die Umstände angibt, unter denen Example Corp handelt. Da Sie der Vertrauensrichtlinie **AWS 1:** eine Bedingung mit Ihrer eigenen externen ID (12345) hinzugefügt habenExampleRole, schlägt der AssumeRole API-Aufruf fehl. Der andere Kunde wird daran gehindert, unbefugten Zugriff auf Ressourcen in Ihrem Konto zu erhalten (gekennzeichnet durch das rote "X" in der Grafik).

Die externe ID verhindert, dass andere Kunden Example Corp manipuliert, und unwissentlich Zugriff auf Ihre Ressourcen gewährt. 

## Vermeidung des Problems des verwirrten Stellvertreters (dienstübergreifend)
<a name="cross-service-confused-deputy-prevention"></a>

Das folgende Diagramm veranschaulicht das dienstübergreifende Confused Deputy Problem anhand des Interaktionsbeispiels CloudTrail und Amazon S3, bei dem ein nicht autorisierter Akteur CloudTrail Protokolle in einen Amazon S3 S3-Bucket schreibt, auf den er nicht zugreifen darf.

![\[Einem nicht autorisierten Akteur wird mithilfe des CloudTrail Service Principals Zugriff auf einen Amazon S3 S3-Bucket in einem anderen Konto gewährt.\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/cross-service-confused-deputy1.png)


Um zu verhindern, dass ein unberechtigter Akteur das Vertrauen eines AWS Auftraggebers ausnutzt, um sich Zugriff auf Ihre Ressourcen zu verschaffen, geben AWS Service Principals Informationen über die AWS Ressource und die AWS Organisation an AWS-Konto, für die sie handeln.

Diese Informationen sind in globalen Zustandsschlüsselwerten verfügbar, die in einer Ressourcenrichtlinie oder einer Ressourcenkontrollrichtlinie für Anfragen von AWS Service Principals verwendet werden können. Wir empfehlen[aws:SourceArn](reference_policies_condition-keys.md#condition-keys-sourcearn),, [aws:SourceAccount](reference_policies_condition-keys.md#condition-keys-sourceaccount)[aws:SourceOrgID](reference_policies_condition-keys.md#condition-keys-sourceorgid), oder [aws:SourceOrgPaths](reference_policies_condition-keys.md#condition-keys-sourceorgpaths) in Ihren Ressourcenrichtlinien zu verwenden, wenn einem AWS Service Principal die Erlaubnis erteilt wurde, auf eine Ihrer Ressourcen zuzugreifen. Mit diesen Bedingungsschlüsseln können Sie in Ihren Ressourcen- oder Ressourcensteuerungsrichtlinien testen, ob AWS Service Principals, die auf Ihre Ressourcen zugreifen, dies im Namen von AWS Ressourcen tun AWS-Konten, oder ob AWS Organizations Sie es erwarten.
+ Verwenden Sie diese Option`aws:SourceArn`, um einem AWS Service Principal den Zugriff auf Ihre Ressourcen im Namen einer bestimmten Ressource zu ermöglichen, z. B. einer bestimmten AWS CloudTrail Route oder AppStream Flotte.
+ Wird verwendet`aws:SourceAccount`, um einem AWS Service Principal den Zugriff auf Ihre Ressourcen im Namen einer bestimmten Person zu ermöglichen AWS-Konto.
+ Wird verwendet`aws:SourceOrgID`, um einem AWS Service Principal den Zugriff auf Ihre Ressourcen im Namen eines bestimmten Benutzers zu ermöglichen AWS Organizations.
+ Wird verwendet`aws:SourceOrgPaths`, um AWS Service Principal den Zugriff auf Ihre Ressourcen für einen bestimmten AWS Organizations Pfad zu ermöglichen.

Das folgende Diagramm zeigt das dienstübergreifende Szenario „Confused Deputy“, wenn eine Ressource mit dem `aws:SourceAccount` globalen Bedingungskontextschlüssel konfiguriert ist und ein nicht autorisierter Akteur aus einem anderen Konto versucht, auf AWS Ressourcen zuzugreifen, auf die er keinen Zugriff haben soll.

![\[Einem nicht autorisierten Akteur wird mithilfe des CloudTrail Service Principals der Zugriff auf einen Amazon S3 S3-Bucket in einem anderen Konto verweigert.\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/cross-service-confused-deputy2.png)


Mit der Verwendung der globalen Bedingungsschlüssel `aws:SourceArn`, `aws:SourceAccount`, `aws:SourceOrgID` und `aws:SourceOrgPaths` in einer Richtlinie können Sie sicherstellen, dass Service-Prinzipale in Ihrem Namen auf Ihre Ressourcen zugreifen. Wir empfehlen, diese Bedingungsschlüssel immer dann zu verwenden, wenn einem AWS Service Principal Zugriff auf eine Ihrer Ressourcen gewährt wird. 

**Anmerkung**  
Bei einigen AWS-Service Interaktionen gibt es zusätzliche Kontrollmöglichkeiten, um vor dienstübergreifenden Problemen mit verwirrten Stellvertretern zu schützen, die den Benutzerzugriff auf eine Ressource testen. Wenn beispielsweise eine KMS-Schlüsselzuweisung an einen ausgestellt wird AWS-Service, AWS KMS verwendet der Verschlüsselungskontext, der mit der Ressource verknüpft ist, und die Schlüsselzuweisung zum Schutz vor dienstübergreifenden Problemen mit verwirrtem Stellvertreter.  
Weitere Informationen zu servicespezifischen Mechanismen, die dazu beitragen, serviceübergreifende Confused-Deputy-Risiken zu vermeiden, sowie zur Unterstützung von `aws:SourceArn`, `aws:SourceAccount`, `aws:SourceOrgID` und `aws:SourceOrgPaths` finden Sie in der Dokumentation der von Ihnen verwendeten Services.

## Serviceübergreifender Confused-Deputy-Schutz mithilfe ressourcenbasierter Richtlinien
<a name="cross-service-confused-deputy-prevention-resource"></a>

Die folgende Beispielrichtlinie gewährt dem Service Principal `cloudtrail.amazonaws.com` Zugriff auf den Amazon S3 S3-Bucket arn:aws:s3: ::amzn-s3-demo-bucket1, nur wenn der Service Principal im Namen von 111122223333 handelt. AWS-Konto 

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

****  

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

------

Diese Beispiel-Bucket-Richtlinie gewährt dem Service Principal nur dann `appstream.amazonaws.com` Zugriff auf das Powershell-Skript examplefile.psh in s3://amzn-s3-demo-bucket2, wenn er im Namen der angegebenen AppStream Amazon-Flotte handelt, indem er den Flottenarn mit angibt. `aws:SourceArn`

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

****  

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

------

## Serviceübergreifender Confused-Deputy-Schutz mithilfe von Ressourcen-Kontrollrichtlinien
<a name="cross-service-confused-deputy-prevention-resource-control"></a>

Mithilfe von Resource Control Policies (RCP) können Sie dienstübergreifende Confused Deputy Controls auf unterstützte Ressourcen anwenden. AWS-Services RCPs ermöglichen es Ihnen, dienststellenübergreifende Kontrollen für verwirrte Stellvertreter zentral auf Ihre Ressourcen anzuwenden. Sie können Bedingungsschlüssel verwenden AWS Organizations, die `aws:SourceOrgId` an Ihre Organisationseinheiten (OU) oder AWS-Konten in Ihrer Organisation RCPs angehängt sind, ohne bestimmte ressourcenbasierte Richtlinien `aws:SourceOrgPaths` mit Anweisungen versehen zu müssen. Weitere Informationen zu RCPs und unterstützten Diensten finden Sie unter [Richtlinien zur Ressourcenkontrolle (RCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) im *AWS Organizations Benutzerhandbuch*.

Im folgenden Beispiel verweigert RCP AWS Service Principals den Zugriff auf Amazon S3 S3-Buckets in Ihren Mitgliedskonten, wenn der Wert ungleich o- `aws:SourceOrgID` ist. ExampleOrg In der ressourcenbasierten Richtlinie des S3-Buckets muss eine entsprechende Zulassung enthalten sein, damit AWS-Service Prinzipale mit einem Wert gleich o- zugelassen werden können. `SourceOrgID` ExampleOrg

Diese Richtlinie wendet die Steuerung nur auf Anfragen von Service-Prinzipalen (`"Bool": {"aws:PrincipalIsAWSService": "true"}`) an, bei denen der Schlüssel `aws:SourceAccount` vorhanden ist (`"Null": {"aws:SourceAccount": "false"}`), sodass Service-Integrationen, für die die Verwendung des Bedingungsschlüssels nicht erforderlich ist, und Aufrufe Ihrer Prinzipale nicht betroffen sind. Wenn der Bedingungsschlüssel `aws:SourceAccount` im Anfragekontext vorhanden ist, wird die Null-Bedingung als wahr ausgewertet, wodurch `aws:SourceOrgID` erzwungen wird. Wir verwenden `aws:SourceAccount` anstelle von `aws:SourceOrgID` im Null-Bedingungsoperator, sodass die Kontrolle auch dann gilt, wenn die Anfrage von einem Konto stammt, das keiner Organisation angehört.

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

****  

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

------

# Gängige Szenarien für IAM-Rollen
<a name="id_roles_common-scenarios"></a>

Wie bei den meisten AWS Funktionen haben Sie generell zwei Möglichkeiten, eine Rolle zu verwenden: interaktiv in der IAM-Konsole oder programmgesteuert mit den AWS CLI Tools für Windows PowerShell oder der API.
+ IAM-Benutzer in Ihrem Konto können mithilfe der IAM-Konsole eine Rolle *wechseln*, um vorübergehend die Berechtigungen der Rolle in der Konsole zu verwenden. Die Benutzer verlieren ihre ursprünglichen Berechtigungen und übernehmen die Berechtigungen der zugewiesenen Rolle. Wenn der Benutzer die Rolle verlässt, werden die ursprünglichen Berechtigungen wiederhergestellt.
+ Eine Anwendung oder ein Service, der von AWS (wie Amazon EC2) angeboten wird, kann eine Rolle *übernehmen*, indem sie temporäre Sicherheitsanmeldedaten für eine Rolle anfordert, an die programmatische Anfragen gestellt werden können. AWS Wenn Sie eine Rolle auf diese Weise verwenden, müssen Sie keine langfristigen Anmeldeinformationen für jede Entität teilen oder pflegen (indem Sie beispielsweise einen IAM-Benutzer erstellen), die Zugriff auf eine Ressource benötigt.

**Anmerkung**  
In diesem Handbuch stellen die Ausdrücke *zu einer Rolle wechseln* und *eine Rolle übernehmen* Synonyme dar.

Die einfachste Möglichkeit zur Verwendung von Rollen besteht darin, Ihren IAM-Benutzern Berechtigungen zum Wechseln der Rollen zu gewähren, die Sie in Ihrem oder einem anderen AWS-Konto erstellen. Sie können Rollen auf einfache Weise mit der IAM-Konsole wechseln, um Berechtigungen zu verwenden, über die die Rollen normalerweise nicht verfügen sollen, und dann die Rolle verlassen, um diese Berechtigungen zu entziehen. So können Sie den *versehentlichen* Zugriff auf oder die Änderung von sensible Ressourcen vermeiden.

Für komplexere Verwendungen von Rollen, z. B. Gewähren des Zugriffs auf externe Anwendungen und Services, rufen Sie das `AssumeRole`-API auf. Dieser API-Aufruf gibt einen Satz temporärer Anmeldeinformationen zurück, die die Anwendung in nachfolgenden API-Aufrufen verwenden kann. Aktionen, die mit den temporären Anmeldeinformationen aufgerufen werden, verfügen nur über die von der zugewiesenen Rolle gewährten Berechtigungen. Eine Anwendung muss die Rolle nicht wie der Benutzer über die Konsole "verlassen". Die Anwendung verwendet einfach nicht mehr die temporären Anmeldeinformationen und führt die Aufrufe nunmehr mit den ursprünglichen Anmeldeinformationen durch.

Verbundbenutzer melden sich mit den Anmeldeinformationen eines Identitätsanbieters (IdP) an. AWS stellt dann dem vertrauenswürdigen IdP temporäre Anmeldeinformationen zur Verfügung, die an den Benutzer weitergegeben werden, damit er sie in nachfolgende AWS Ressourcenanfragen einbezieht. Diese Anmeldeinformationen enthalten die Berechtigungen für die zugewiesene Rolle.

Dieser Abschnitt enthält eine Übersicht über die folgenden Szenarien:
+ [Gewähren Sie einem IAM-Benutzer in einem Konto AWS-Konto , das Sie besitzen, Zugriff auf Ressourcen in einem anderen Konto, das Sie besitzen](id_roles_common-scenarios_aws-accounts.md)
+ [Bereitstellen des Zugriffs auf nicht- AWS -Workloads](id_roles_common-scenarios_non-aws.md)
+ [Gewähren Sie den IAM-Benutzern in AWS-Konten von Dritten Zugriff](id_roles_common-scenarios_third-party.md)
+ [Ermöglichen Sie den Zugriff auf Dienste, die von AWS to AWS resources angeboten werden](id_roles_common-scenarios_services.md)
+ [Gewähren Sie den Zugriff für extern authentifizierte Benutzer (Identitätsverbund)](id_roles_common-scenarios_federated-users.md)

# Zugriff für einen IAM-Benutzer in einem anderen AWS-Konto , den Sie besitzen
<a name="id_roles_common-scenarios_aws-accounts"></a>

Sie können Ihren IAM-Benutzern die Erlaubnis erteilen, zu Rollen innerhalb Ihrer eigenen AWS-Konto oder zu Rollen zu wechseln, die in anderen Rollen definiert sind AWS-Konten , die Ihnen gehören. 

**Anmerkung**  
Wenn Sie den Zugriff auf ein Konto gewähren möchten, das Sie nicht besitzen oder kontrollieren, finden Sie weitere Informationen unter [Zugriff auf AWS-Konten Eigentum Dritter](id_roles_common-scenarios_third-party.md) im weiteren Verlauf in diesem Thema. 

Angenommen, Sie haben Amazon EC2-Instances, die für die Organisation sehr wichtig sind. Statt Benutzern die Berechtigung zu erteilen, solche Instances zu beenden, können Sie eine Rolle mit diesen Berechtigungen erstellen. Erlauben Sie dann den Administratoren, zu jener Rolle zu wechseln, wenn sie eine Instance beenden müssen. Dadurch werden den Instances folgende Schutzebenen hinzugefügt:
+ Sie müssen Ihren Benutzern explizit die Berechtigung zur Übernahme der Rolle erteilen.
+ Ihre Benutzer müssen aktiv zu der Rolle wechseln, indem sie die AWS-Managementkonsole oder AWS API verwenden, AWS CLI oder die Rolle übernehmen.
+ Sie können die Multi-Factor Authentication (MFA) zur Rolle hinzufügen, sodass nur die Benutzer, die sich mit einem MFA-Gerät anmelden, die Rolle übernehmen können. Weitere Informationen dazu, wie Sie eine Rolle konfigurieren, sodass von den Benutzern, die die Rolle übernehmen müssen, zunächst eine Multi-Factor Authentication (MFA) verlangt wird, finden Sie unter [Sicherer API-Zugriff mit MFA](id_credentials_mfa_configure-api-require.md).

Wir empfehlen diese Herangehensweise, um das das *Prinzip der geringsten Zugriffsrechte* durchzusetzen. Das bedeutet, dass erweiterte Berechtigungen nur in Zeiten gewährt werden, in denen diese zur Durchführung bestimmter Aufgaben benötigt werden. Mit den Rollen können Sie versehentliche Änderungen an sensiblen Umgebungen verhindern, vor allem in Verbindung mit der [-Überwachung](cloudtrail-integration.md), um sicherzustellen, dass Rollen nur bei Bedarf verwendet werden.

Wenn Sie eine Rolle für diesen Zweck erstellen, geben Sie in der Vertrauensrichtlinie der Rolle im `Principal`-Element die IDs der Konten an, für deren Benutzer Sie Zugriffsberechtigungen erteilen müssen. Anschließend können Sie bestimmten Benutzern in den anderen Konten Berechtigungen erteilen, um zu dieser Rolle zu wechseln. Informationen darüber, ob Auftraggeber in Konten außerhalb Ihrer Vertrauenszone (vertrauenswürdige Organisation oder Konto) Zugriff zur Annahme Ihrer Rollen haben, finden Sie unter [Was ist IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html).

Ein Benutzer in einem Konto kann zu einer Rolle in demselben oder einem anderen Konto wechseln. Während die Rolle verwendet wird, können die Benutzer nur die Aktionen durchführen und auf die Ressourcen zugreifen, die von der Rolle zugelassen sind. Die ursprünglichen Berechtigungen der Benutzer sind ausgesetzt. Wenn der Benutzer die Rolle verlässt, werden die ursprünglichen Benutzerberechtigungen wiederhergestellt.

## Beispielszenario mit getrennten Entwicklungs- und Produktionskonten
<a name="id_roles_common-scenarios_aws-accounts-example"></a>

Stellen Sie sich vor, Ihr Unternehmen verfügt über mehrere AWS-Konten , um eine Entwicklungsumgebung von einer Produktionsumgebung zu isolieren. Benutzer im Entwicklungskonto müssen gelegentlich auf Ressourcen im Produktionskonto zugreifen. Sie benötigen beispielsweise kontoübergreifenden Zugriff, wenn Sie ein Update aus der Entwicklungsumgebung in die Produktionsumgebung übernehmen wollen. Auch wenn Sie verschiedene Identitäten (und Passwörter) für die Benutzer, die in beiden Konten arbeiten, erstellen könnten, erschwert das Verwalten von Anmeldeinformationen für mehrere Konten die Identitätsverwaltung. In der folgenden Abbildung werden alle Benutzer im Development-Konto verwaltet. Einige Entwickler benötigen jedoch eingeschränkten Zugriff auf das Production-Konto. Das Development-Konto verfügt über zwei Gruppen: Tester und Entwickler und jede Gruppe hat ihre eigene Richtlinie.

![\[Verwenden Sie eine Rolle zum Delegieren von Berechtigungen für einen Benutzer in einem anderen Konto\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/roles-usingroletodelegate.png)


1. Im Produktionskonto verwendet ein Administrator IAM, um die `UpdateApp`-Rolle in diesem Konto zu erstellen. Der Administrator definiert in der Rolle eine Vertrauensrichtlinie, in der das Development-Konto als `Principal` angegeben wird, was bedeutet, dass autorisierte Benutzer aus dem Development-Konto die Rolle `UpdateApp` verwenden dürfen. Der Administrator definiert auch eine Berechtigungsrichtlinie für die Rolle, die festlegt, welche Rollenbenutzer Lese- und Schreibberechtigungen für den Amazon S3`productionapp`-Bucket namens erhalten.

   Der Administrator gibt die entsprechenden Informationen dann an Benutzer weiter, die die Rolle übernehmen müssen. Diese Informationen sind die Kontonummer und der Name der Rolle (für AWS Konsolenbenutzer) oder der Amazon-Ressourcenname (ARN) (für AWS CLI unseren AWS API-Zugriff). Der Rollen-ARN könnte wie `arn:aws:iam::123456789012:role/UpdateApp` aussehen, wobei die Rolle `UpdateApp` benannt ist und die Rolle unter der Kontonummer 123456789012 erstellt wurde.
**Anmerkung**  
Der Administrator kann optional die Rolle konfigurieren, sodass von den Benutzern, die die Rolle übernehmen müssen, zunächst eine Multi-Factor Authentication (MFA) verlangt wird. Weitere Informationen finden Sie unter [Sicherer API-Zugriff mit MFA](id_credentials_mfa_configure-api-require.md). 

1. Der Administrator gewährt den Mitgliedern der Entwicklergruppe im Entwicklungskonto die Berechtigungen, um zur betreffenden Rolle wechseln zu können. Dazu wird der Entwicklergruppe die Erlaubnis erteilt, die AWS -Security-Token-Service (AWS STS) `AssumeRole` -API für die `UpdateApp` Rolle aufzurufen. Alle IAM-Benutzer der Entwickler-Gruppe im Development-Konto können nun zur Rolle `UpdateApp` im Production-Konto wechseln. Andere Benutzer, die sich nicht in der Entwickler-Gruppe befinden, haben keine Berechtigung, um zur Rolle zu wechseln, und sind folglich nicht in der Lage, auf den S3-Bucket im Production-Konto zuzugreifen.

1. Der Benutzer fordert den Wechsel zur Rolle an:
   + AWS Konsole: Der Benutzer wählt den Kontonamen in der Navigationsleiste und wählt „**Rolle wechseln**“. Der Benutzer gibt die Konto-ID (oder Alias) und den Namen der Rolle an. Alternativ kann der Benutzer auf einen Link in der vom Administrator gesendeten E-Mail klicken. Der Link leitet den Benutzer zur Seite **Switch Role (Rolle wechseln)** weiter, in der die Details bereits ausgefüllt sind.
   + AWS API/AWS CLI: Ein Benutzer in der Gruppe Entwickler des Entwicklungskontos ruft die `AssumeRole` Funktion auf, um Anmeldeinformationen für die `UpdateApp` Rolle abzurufen. Der Benutzer übergibt den ARN der Rolle `UpdateApp` als Teil des Aufrufs. Eine vom Benutzer in der Tester-Gruppe gestellte gleiche Anforderung schlägt fehl, weil die Tester keine Berechtigung zum Aufruf von `AssumeRole` für den ARN der Rolle `UpdateApp` haben.

1. AWS STS gibt temporäre Anmeldeinformationen zurück:
   + AWS Konsole: AWS STS überprüft die Anfrage anhand der Vertrauensrichtlinie der Rolle, um sicherzustellen, dass die Anfrage von einer vertrauenswürdigen Entität stammt (was es ist: das Entwicklungskonto). AWS STS Gibt nach der Überprüfung [temporäre Sicherheitsanmeldedaten](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) an die AWS Konsole zurück.
   + API/CLI: AWS STS überprüft die Anfrage anhand der Vertrauensrichtlinie der Rolle, um sicherzustellen, dass die Anfrage von einer vertrauenswürdigen Entität stammt (was es ist: das Entwicklungskonto). AWS STS Gibt nach der Überprüfung [temporäre Sicherheitsanmeldedaten an die Anwendung](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) zurück.

1. Die temporären Anmeldeinformationen ermöglichen den Zugriff auf die AWS Ressource:
   + AWS Konsole: Die AWS Konsole verwendet die temporären Anmeldeinformationen im Namen des Benutzers für alle nachfolgenden Konsolenaktionen, in diesem Fall zum Lesen und Schreiben in den `productionapp` Bucket. Die Konsole kann auf keine anderen Ressourcen im Production-Konto zurückgreifen. Wenn der Benutzer die Rolle verlässt, erhält er seine ursprünglichen Berechtigungen, über die er vor dem Wechseln der Rolle verfügt hat, zurück.
   + API/CLI: Die Anwendung verwendet die temporären Anmeldeinformationen, um den Bucket `productionapp` zu aktualisieren. Mit den temporären Sicherheitsanmeldeinformationen kann die Anwendung nur Lese- und Schreibvorgänge im Bucket `productionapp` ausführen und auf keine anderen Ressourcen im Production-Konto zugreifen. Die Anwendung muss die Rolle nicht verlassen, sondern unterlässt stattdessen die Verwendung der temporären Anmeldeinformationen und verwendet in den nachfolgenden API-Aufrufen die ursprünglichen Anmeldeinformationen.

## Weitere Ressourcen
<a name="id_roles_common-scenarios_more-info"></a>

Weitere Informationen finden Sie hier:
+ [IAM-Tutorial: Delegieren Sie den Zugriff über AWS Konten hinweg mithilfe von IAM-Rollen](tutorial_cross-account-with-roles.md)

# Zugriff für AWS Nicht-Workloads
<a name="id_roles_common-scenarios_non-aws"></a>

[Eine [IAM-Rolle](id_roles.md) ist ein Objekt in AWS Identity and Access Management (IAM), dem Berechtigungen zugewiesen wurden.](access_policies.md) Wenn Sie [diese Rolle mit einer IAM-Identität oder einer Identität von außerhalb übernehmen](id_roles_manage-assume.md) AWS, erhalten Sie temporäre Sicherheitsanmeldedaten für Ihre Rollensitzung. Möglicherweise laufen Workloads in Ihrem Rechenzentrum oder einer anderen Infrastruktur außerhalb dieser Infrastruktur AWS , die auf Ihre AWS Ressourcen zugreifen muss. Anstatt langfristige Zugriffsschlüssel zu erstellen, zu verteilen und zu verwalten, können Sie Roles Anywhere (IAM AWS Identity and Access Management Roles Anywhere) verwenden, um Ihre Nicht-Workloads zu authentifizieren. AWS IAM Roles Anywhere verwendet X.509-Zertifikate Ihrer Zertifizierungsstelle (CA), um Identitäten zu authentifizieren und den Zugriff auf sichere Weise AWS-Services mit den temporären Anmeldeinformationen zu ermöglichen, die von einer IAM-Rolle bereitgestellt werden.

**So verwenden Sie IAM Roles Anywhere**

1. Richten Sie eine CA mit [AWS Private Certificate Authority](https://docs.aws.amazon.com/privateca/latest/userguide/PcaWelcome.html) ein oder verwenden Sie eine CA aus Ihrer eigenen PKI-Infrastruktur.

1. Nachdem Sie eine Zertifizierungsstelle eingerichtet haben, erstellen Sie in IAM Roles Anywhere ein Objekt, das *Vertrauensanker* genannt wird. Dieser Anker stellt für die Authentifizierung Vertrauen zwischen IAM Roles Anywhere und Ihrer Zertifizierungsstelle her.

1. Anschließend können Sie Ihre vorhandenen IAM-Rollen konfigurieren oder neue Rollen erstellen, die dem IAM-Roles-Anywhere-Dienst vertrauen.

1. Authentifizieren Sie Ihre AWS Nicht-Workloads mit IAM Roles Anywhere mithilfe des Trust Anchor. AWS gewährt der IAM-Rolle, die Zugriff auf Ihre Ressourcen hat, temporäre Anmeldeinformationen, die keine AWS Workloads sind. AWS 

## Weitere Ressourcen
<a name="id_roles_non-aws_additional_resources"></a>

In den folgenden Ressourcen erfahren Sie mehr über die Bereitstellung des Zugriffs auf Workloads, die nicht von AWS stammen.
+ Weitere Informationen zum Konfigurieren von IAM Roles Anywhere finden Sie unter [Was ist AWS Identity and Access Management Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) im *IAM-Roles-Anywhere-Benutzerhandbuch*.
+ Informationen zum Einrichten einer Infrastruktur für öffentliche Schlüssel (PKI) für IAM Roles Anywhere finden Sie unter [IAM Roles Anywhere mit einer externen Zertifizierungsstelle](https://aws.amazon.com/blogs/) im *AWS -Sicherheits-Blog*.

# Zugriff auf AWS-Konten Eigentum Dritter
<a name="id_roles_common-scenarios_third-party"></a>

Wenn Dritte Zugriff auf die AWS Ressourcen Ihrer Organisation benötigen, können Sie Rollen verwenden, um den Zugriff auf diese Ressourcen zu delegieren. Zum Beispiel könnte ein externer Benutzer einen Service zur Verwaltung Ihrer AWS -Ressourcen anbieten. Mit IAM-Rollen können Sie diesen Dritten Zugriff auf Ihre AWS Ressourcen gewähren, ohne Ihre AWS Sicherheitsanmeldedaten weitergeben zu müssen. Stattdessen kann der Drittanbieter auf Ihre AWS Ressourcen zugreifen, indem er eine Rolle übernimmt, die Sie in Ihrem AWS-Konto erstellen. Informationen darüber, ob Auftraggeber in Konten außerhalb Ihrer Vertrauenszone (vertrauenswürdige Organisation oder Konto) Zugriff zur Annahme Ihrer Rollen haben, finden Sie unter [Was ist IAM Access Analyzer?](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html).

Externe Benutzer müssen Ihnen die folgenden Informationen bereitstellen, damit Sie eine von ihnen übernehmbare Rolle erstellen können:
+ **Die AWS-Konto ID des Drittanbieters**. Sie legen diese AWS-Konto -ID als Prinzipal fest, wenn Sie die Vertrauensrichtlinie für die Rolle definieren.
+ **Eine externe ID zur eindeutigen Zuordnung der Rolle**. Die externe ID kann eine beliebige geheime Kennung sein, die Ihnen und dem Drittanbieter bekannt ist. Sie können beispielsweise eine Rechnungs-ID zwischen Ihnen und dem externen Benutzer verwenden. Benutzen Sie aber keine leicht zu erratenden Zeichenfolgen wie den Namen oder die Telefonnummer des externen Benutzers. Sie müssen diese ID festlegen, wenn Sie die Vertrauensrichtlinie für die Rolle definieren. Der externe Benutzer muss diese ID angeben, wenn er die Rolle übernimmt.
+ **Die Berechtigungen, die der externe Benutzer benötigt, um mit Ihren AWS -Ressourcen arbeiten zu können**. Sie müssen diese Berechtigungen festlegen, wenn Sie die Berechtigungsrichtlinie für die Rolle definieren. Diese Richtlinie bestimmt, welche Aktionen der externe Benutzer ausführen darf und auf welche Ressourcen er Zugriff hat.

Nachdem Sie die Rolle erstellt haben, müssen Sie dem externen Benutzer den Amazon Resource Name (ARN) der Rolle mitteilen. Dieser benötigt den ARN der Rolle, um sie übernehmen zu können.

**Wichtig**  
Wenn Sie Dritten Zugriff auf Ihre AWS Ressourcen gewähren, können diese auf jede Ressource zugreifen, die Sie in der Richtlinie angeben. Die vom externen Benutzer genutzten Ressourcen werden Ihnen in Rechnung gestellt. Stellen Sie sicher, dass Sie die Nutzung Ihrer Ressourcen sinnvoll einschränken.

## Extern IDs für den Zugriff durch Dritte
<a name="id_roles_third-party_external-id"></a>

Eine externe ID ermöglicht dem Benutzer, der die Rolle übernimmt, die Umstände anzugeben, unter denen er agiert. Außerdem kann der Kontoinhaber die Umstände festlegen, unter denen die Rolle angenommen werden kann. Die primäre Funktion des externen Ausweises besteht darin, [Das Confused-Deputy-Problem](confused-deputy.md) zu lösen und zu verhindern.

**Wichtig**  
AWS behandelt die externe ID nicht als geheim. Nachdem Sie ein Geheimnis wie ein Zugriffsschlüsselpaar oder ein Passwort erstellt haben AWS, können Sie es nicht erneut anzeigen. Die externe ID für eine Rolle kann von jedem gesehen werden, der berechtigt ist, die Rolle anzusehen. 

## Wann sollte ich die externe ID verwenden?
<a name="external-id-use"></a>

Verwenden Sie in folgenden Situationen eine externe ID:
+ Sie sind AWS-Konto Eigentümer und haben eine Rolle für einen Drittanbieter konfiguriert, der zusätzlich zu Ihrer Rolle AWS-Konten auf andere zugreift. Sie sollten den Dritten um eine externe ID bitten, die er mit angeben muss, wenn er Ihre Rolle annimmt. Dann führen Sie eine Prüfung durch, um zu testen, ob diese externe ID in der Vertrauensrichtlinie Ihrer Rolle vorhanden ist. Auf diese Weise wird sichergestellt, dass die externe Partei Ihre Rolle nur annehmen kann, wenn sie in Ihrem Namen handelt.
+ Sie sind wie Beispielunternehmen in unserem vorherigen Szenario in einer Position, in der Sie Rollen für verschiedene Kunden annehmen, Sie sollten jedem Kunden eine eindeutige externe ID zuweisen und Ihre Kunden anweisen, die externe ID in die Vertrauensrichtlinie ihrer Rolle aufzunehmen. Anschließend müssen Sie in allen Anforderungen, in der Sie Rollen annehmen möchten, die korrekte externe ID angeben.

  Sie verfügen wahrscheinlich bereits über eine eindeutige ID für jeden Kunden, die Sie als externe ID verwenden können. Bei der externen ID handelt es sich nicht um einen Wert, den Sie explizit erstellen oder separat nur für diesen Zweck nachverfolgen müssen.

  Geben Sie die externe ID in allen `AssumeRole`-API-Aufrufen an. Wenn Sie von einem Kunden einen Rollen-ARN erhalten, testen Sie darüber hinaus mit und ohne die korrekte externe ID, ob Sie die Rolle annehmen können. Wenn Sie die Rolle ohne die korrekte externe ID annehmen können, speichern Sie den Rollen-ARN des Kunden nicht in Ihrem System. Warten Sie, bis der Kunde die Vertrauensrichtlinie der Rolle aktualisiert hat und eine Überprüfung der externen ID vornimmt. So helfen Sie Ihren Kunden, sich korrekt zu verhalten und sich selbst und Ihr Unternehmen vor dem Problem des verwirrten Stellvertreters zu schützen.

## Beispielszenario mit Verwendung einer externen ID
<a name="id_roles_third-party_example"></a>

Nehmen wir zum Beispiel an, Sie beschließen, ein Drittanbieter namens Example Corp mit der Überwachung Ihrer Kosten AWS-Konto und der Kostenoptimierung zu beauftragen. Um Ihre täglichen Ausgaben verfolgen zu können, muss Example Corp auf Ihre AWS Ressourcen zugreifen. Example Corp überwacht zudem viele weitere AWS -Konten anderer Kunden.

Gewähren Sie Example Corp keinen Zugriff auf einen IAM-Benutzer und dessen langfristige Anmeldeinformationen in Ihrem AWS -Konto. Verwenden Sie stattdessen eine IAM-Rolle und deren temporäre Sicherheitsanmeldeinformationen. Eine IAM-Rolle bietet einen Mechanismus, mit dem Dritte auf Ihre AWS Ressourcen zugreifen können, ohne langfristige Anmeldeinformationen (z. B. einen IAM-Benutzerzugriffsschlüssel) weitergeben zu müssen.

Etablieren Sie mithilfe einer IAM-Rolle eine Vertrauensbeziehung zwischen Ihrem AWS-Konto und dem Konto von Example Corp. Nachdem diese Beziehung hergestellt wurde, kann ein Mitglied des Example Corp-Kontos die AWS -Security-Token-Service [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API aufrufen, um temporäre Sicherheitsanmeldedaten zu erhalten. Die Mitglieder von Example Corp können die Anmeldeinformationen dann verwenden, um auf AWS Ressourcen in Ihrem Konto zuzugreifen. 

**Anmerkung**  
Weitere Informationen zu den AssumeRole und anderen AWS API-Vorgängen, die Sie aufrufen können, um temporäre Sicherheitsanmeldedaten zu erhalten, finden Sie unter[AWS STS Referenzen vergleichen](id_credentials_sts-comparison.md).

Nachfolgend ist dieses Szenario detaillierter aufgeschlüsselt:

1. Sie beauftragen Beispielunternehmen und diese erstellen eine eindeutige Kunden-ID für Sie. Sie stellen Ihnen diese eindeutige Kunden-ID und ihre AWS-Konto Nummer zur Verfügung. Sie benötigen diese Informationen, um im nächsten Schritt eine IAM-Rolle zu erstellen. 
**Anmerkung**  
Example Corp kann einen beliebigen Zeichenkettenwert für die verwenden ExternalId, sofern dieser für jeden Kunden eindeutig ist. Es kann sich dabei um eine Kundenkontonummer oder eine zufällige Zeichenfolge handeln, solange nicht für zwei Kunden derselbe Wert verwendet wird. Diese Nummer muss nicht geheim gehalten werden. Example Corp muss den ExternalId Wert jedem Kunden zur Verfügung stellen. Wichtig dabei ist, dass diese ID von Unternehmen XY und ***nicht*** von den Kunden generiert wird, um sicherzustellen, dass jede externe ID einzigartig ist.

1. Sie melden sich an AWS und erstellen eine IAM-Rolle, die Example Corp Zugriff auf Ihre Ressourcen gewährt. Wie bei allen IAM-Rollen verfügt die Rolle über zwei Richtlinien, eine Berechtigungsrichtlinie und eine Vertrauensrichtlinie. Über die Vertrauensrichtlinie der Rolle wird festgelegt, wer die Rolle annehmen kann. In unserem Beispielszenario gibt die Richtlinie die AWS-Konto Anzahl von Example Corp als an`Principal`. Dies ermöglicht Identitäten dieses Kontos, die Rolle anzunehmen. Außerdem fügen Sie der Vertrauensrichtlinie ein `[Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition)`-Element hinzu. Mit diesem `Condition` wird der Kontextschlüssel `ExternalId` getestet, um sicherzustellen, dass er mit der eindeutigen Kunden-ID von Beispielunternehmen übereinstimmt.

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

1. In der Berechtigungsrichtlinie der Rolle ist festgelegt, welche Berechtigungen mit der Rolle verliehen werden. Sie können zum Beispiel festlegen, dass die Rolle nur die Verwaltung Ihrer Amazon EC2- und Amazon RDS-Ressourcen erlaubt, nicht aber die Verwaltung Ihrer IAM-Benutzer oder -Gruppen. In unserem Beispielszenario können Sie Beispielunternehmen über die Berechtigungsrichtlinie schreibgeschützten Zugriff auf sämtliche Ressourcen in Ihrem Konto gewähren.

1. Nachdem Sie die Rolle erstellt haben, stellen Sie Beispielunternehmen den Amazon-Ressourcennamen (ARN) der Rolle bereit.

1. Wenn Example Corp auf Ihre AWS Ressourcen zugreifen muss, ruft jemand aus dem Unternehmen die AWS `sts:AssumeRole` API auf. Der Aufruf beinhaltet den ARN der Rolle, die übernommen werden soll, und den ExternalId Parameter, der ihrer Kunden-ID entspricht.

Wenn die Anfrage von jemandem stammt, der Example Corp's verwendet AWS-Konto, und wenn der Rollen-ARN und die externe ID korrekt sind, ist die Anfrage erfolgreich. Anschließend werden temporäre Sicherheitsanmeldedaten bereitgestellt, mit denen Example Corp auf die AWS Ressourcen zugreifen kann, die Ihre Rolle zulässt.

Anders ausgedrückt, wenn eine Rollenrichtlinie eine externe ID enthält, muss jemand, der die Rolle annehmen möchte, als Auftraggeber in der Rolle angegeben sein und muss die korrekte externe ID angeben.

## Wichtige Punkte für externe IDs
<a name="id_roles_third-party_key-points"></a>
+ In einer Umgebung mit mehreren Mandanten, in der Sie mehrere Kunden mit unterschiedlichen AWS Konten unterstützen, empfehlen wir, jeweils eine externe ID zu verwenden. AWS-Konto Diese ID sollte eine zufällige Zeichenfolge sein, die von der Drittpartei generiert wird.
+ Um zu verlangen, dass der Drittanbieter beim Übernehmen einer Rolle eine externe ID bereitstellt, aktualisieren Sie die Vertrauensrichtlinie der Rolle mit der externen ID Ihrer Wahl.
+ Wenn Sie eine externe ID angeben möchten, wenn Sie eine Rolle übernehmen, verwenden Sie die AWS API AWS CLI oder, um diese Rolle anzunehmen. Weitere Informationen finden Sie unter [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)STS-API-Vorgang oder [STS-Befehlsübernahme-CLI-Vorgang](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html).
+ Der Wert `ExternalId` muss mindestens 2 Zeichen und darf höchstens 1.224 Zeichen lang sein. Der Wert muss alphanumerisch sein ohne Leerzeichen. Er kann auch die folgenden Zeichen enthalten: Pluszeichen (\$1), Gleichheitszeichen (=), Komma (,), Punkt (.), At-Zeichen (@), Doppelpunkt (:), Schrägstrich (/) und Bindestrich (-).

## Weitere Ressourcen
<a name="id_roles_third-party_additional_resources"></a>

Die folgenden Ressourcen können Ihnen dabei helfen, mehr über die Bereitstellung des Zugriffs auf AWS-Konten im Besitz von Drittanbieter zu erfahren.
+ Informationen darüber, wie Sie anderen erlauben können, Aktionen in Ihrem System auszuführen AWS-Konto, finden Sie unter. [Rolle mithilfe benutzerdefinierter Vertrauensrichtlinien erstellen](id_roles_create_for-custom.md)
+ Informationen dazu, wie Sie die Berechtigung zum Wechseln zu einer Rolle gewähren, finden Sie unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md)
+ Informationen dazu, wie Sie temporäre Sicherheitsanmeldedaten erstellen und vertrauenswürdigen Benutzern zur Verfügung stellen, [Berechtigungen für temporäre Sicherheits-Anmeldeinformationen](id_credentials_temp_control-access.md).

# Zugang zu einem AWS Service
<a name="id_roles_common-scenarios_services"></a>

Bei vielen AWS Diensten müssen Sie mithilfe von Rollen steuern, auf welche Dienste zugreifen können. Eine Rolle, die ein Service übernimmt, um Aktionen in Ihrem Namen durchzuführen, wird als [Servicerolle](id_roles.md#iam-term-service-role) bezeichnet. Wenn eine Rolle einem speziellen Zweck für einen Service dient, kann sie als [serviceverknüpfte Rolle](id_roles.md#iam-term-service-linked-role) kategorisiert werden. In der [AWS -Dokumentation](https://docs.aws.amazon.com/) für die einzelnen Services finden Sie Informationen dazu, ob der jeweilige Service Rollen verwendet und wie dem Service eine Rolle zur Nutzung zugewiesen wird.

Einzelheiten zum Erstellen einer Rolle zur Delegierung des Zugriffs auf einen von angebotenen Dienst finden Sie AWS unter[Erstellen Sie eine Rolle, um Berechtigungen an einen AWS Dienst zu delegieren](id_roles_create_for-service.md).

# Zugriff für extern authentifizierte Benutzer gewähren (Identitätsverbund)
<a name="id_roles_common-scenarios_federated-users"></a>

Ihre Benutzer haben möglicherweise bereits Identitäten außerhalb von AWS, z. B. in Ihrem Unternehmensverzeichnis. Wenn diese Benutzer mit AWS Ressourcen arbeiten müssen (oder mit Anwendungen arbeiten müssen, die auf diese Ressourcen zugreifen), benötigen diese Benutzer auch AWS Sicherheitsanmeldeinformationen. Sie können mithilfe einer IAM-Rolle Berechtigungen für Benutzer festlegen, deren Identität in einem Verbund Ihres Unternehmens oder eines externen Identitätsanbieters (IdP) vereinigt ist.

**Anmerkung**  
Als bewährte Sicherheitsmethode empfehlen wir, den Benutzerzugriff in [IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/what-is.html) mit einem Identitätsverbund zu verwalten, anstatt IAM-Benutzer zu erstellen. Informationen zu bestimmten Situationen, in denen ein IAM-Benutzer erforderlich ist, finden Sie unter [Wann sollte ein IAM-Benutzer (anstelle einer Rolle) erstellt werden?](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose).

## Zusammenführung von Benutzern einer mobilen oder webbasierten Anwendung mit Amazon Cognito
<a name="id_roles_common-scenarios_federated-users-cognito"></a>

Wenn Sie eine mobile oder webbasierte App erstellen, die auf AWS Ressourcen zugreift, benötigt die App Sicherheitsanmeldedaten, um programmatische Anfragen an sie stellen zu können. AWS Für die meisten mobilen Anwendungsszenarien empfehlen wir die Verwendung von [Amazon Cognito](https://aws.amazon.com/cognito/). Sie können diesen Dienst mit dem [AWS Mobile SDK for iOS](https://aws.amazon.com/sdkforios/) und dem [AWS Mobile SDK for Android und Fire OS](https://aws.amazon.com/sdkforandroid/) verwenden, um eindeutige Identitäten für Benutzer zu erstellen und sie für einen sicheren Zugriff auf Ihre AWS Ressourcen zu authentifizieren. Amazon Cognito unterstützt die Identitätsanbieter, die im nächsten Abschnitt aufgeführt werden, sowie die [vom Entwickler authentifizierten Identitäten](https://aws.amazon.com/blogs/mobile/amazon-cognito-announcing-developer-authenticated-identities) und nicht authentifizierten Zugriff (Gast). Amazon Cognito stellt auch API-Operationen für die Synchronisierung von Benutzerdaten bereit, sodass diese erhalten bleiben, wenn die Benutzer zwischen Geräten wechseln. Weitere Informationen finden Sie unter [Amazon Cognito für mobile Apps](id_federation_common_scenarios.md#id_roles_providers_oidc_cognito). 

## Vereinigen von Benutzern in einem Verbund mit öffentlichen Identitätsdienstanbietern oder OpenID Connect
<a name="id_roles_common-scenarios_federated-users-openId"></a>

Verwenden Sie möglichst Amazon Cognito für mobile und webbasierte Anwendungsszenarien. Amazon Cognito erledigt den Großteil der behind-the-scenes Arbeit mit öffentlichen Identitätsanbieterdiensten für Sie. Es funktioniert mit den gleichen Drittanbieterservices und unterstützt auch anonyme Anmeldungen. Bei anspruchsvolleren Szenarien können Sie jedoch direkt mit einem Drittanbieterservice arbeiten, wie Login with Amazon, Facebook, Google oder einem mit OpenID Connect (OIDC) kompatiblen Identitätsanbieter. Weitere Informationen zur Verwendung des OIDC-Verbunds mithilfe eines dieser Services finden Sie unter [OIDC-Verbund](id_roles_providers_oidc.md).

## Vereinigen von Benutzern in einem Verbund mit SAML 2.0
<a name="id_roles_common-scenarios_federated-users-saml20"></a>

Wenn Ihre Organisation bereits ein Identity Provider-Softwarepaket verwendet, das SAML 2.0 (Security Assertion Markup Language 2.0) unterstützt, können Sie Vertrauen zwischen Ihrer Organisation als Identity Provider (IdP) und AWS als Service Provider aufbauen. Anschließend können Sie SAML verwenden, um Ihren Benutzern föderiertes Single Sign-On (SSO) AWS-Managementkonsole oder Verbundzugriff zum Aufrufen von API-Vorgängen bereitzustellen. AWS Wenn Ihr Unternehmen beispielsweise Microsoft Active Directory und Active Directory Federation Services verwendet, können Sie dies mit SAML 2 in einem Verbund vereinigen. Weitere Informationen zum Verbund von Benutzern mit SAML 2.0 finden Sie unter [SAML 2.0-Föderation](id_roles_providers_saml.md).

## Vereinigen von Benutzern in einem Verbund durch Erstellen einer benutzerdefinierten Identity Broker-Anwendung
<a name="id_roles_common-scenarios_federated-users-idbroker"></a>

Wenn Ihre Identitätsquelle nicht mit SAML 2.0 kompatibel ist, können Sie eine benutzerdefinierte Identity Broker-Anwendung erstellen, um eine ähnliche Funktion durchzuführen. Die Brokeranwendung authentifiziert Benutzer, fordert temporäre Anmeldeinformationen für Benutzer an und stellt sie dann dem AWS Benutzer für den Zugriff auf Ressourcen zur Verfügung. AWS 

Beispielsweise hat Example Corp. viele Mitarbeiter, die interne Anwendungen ausführen müssen, die auf die Ressourcen des AWS Unternehmens zugreifen. Die Mitarbeiter verfügen bereits über Identitäten im Identitäts- und Authentifizierungssystem des Unternehmens und das Beispielunternehmen möchte keinen separaten IAM-Benutzer für jeden Mitarbeiter erstellen.

Bob ist Entwickler bei Example Corp. Um internen Anwendungen von Example Corp. den Zugriff auf die AWS Ressourcen des Unternehmens zu ermöglichen, entwickelt Bob eine benutzerdefinierte Identity Broker-Anwendung. Die Anwendung überprüft, ob Mitarbeiter beim vorhandenen Identitäts- und Authentifizierungssystem des Beispielunternehmens angemeldet sind, das möglicherweise LDAP, Active Directory oder ein anderes System nutzt. Die Identity Broker-Anwendung ruft dann die temporären Anmeldeinformationen für die Mitarbeiter ab. Dieses Szenario ähnelt dem vorherigen Szenario (eine mobile App, die ein benutzerdefiniertes Authentifizierungssystem verwendet), mit der Ausnahme, dass die Anwendungen, die Zugriff auf AWS Ressourcen benötigen, alle innerhalb des Unternehmensnetzwerks ausgeführt werden und das Unternehmen über ein vorhandenes Authentifizierungssystem verfügt.

Zum Abrufen von temporären Sicherheitsanmeldeinformationen ruft die Identity Broker-Anwendung entweder `AssumeRole` oder `GetFederationToken` auf, je nachdem, wie Bob die Richtlinien für die Benutzer verwalten möchte und wann die temporären Anmeldeinformationen ablaufen sollen. (Weitere Informationen zu den Unterschieden zwischen diesen API-Operationen finden Sie unter [Temporäre IAM Sicherheitsanmeldeinformationen](id_credentials_temp.md) und [Berechtigungen für temporäre Sicherheits-Anmeldeinformationen](id_credentials_temp_control-access.md).) Der Aufruf gibt temporäre Sicherheitsanmeldeinformationen zurück, die aus einer AWS Zugriffsschlüssel-ID, einem geheimen Zugriffsschlüssel und einem Sitzungstoken bestehen. Die Identity Broker-Anwendung stellt diese temporären Sicherheitsanmeldeinformationen der internen Unternehmensanwendung zur Verfügung. Die Anwendung kann dann die temporären Anmeldeinformationen für direkte Aufrufe an AWS verwenden. Die Anwendung speichert die Anmeldeinformationen bis zum Ablaufdatum zwischen und fordert dann einen neuen Satz temporärer Anmeldeinformationen an. Die folgende Abbildung veranschaulicht dieses Szenario.

![\[Beispiel für einen Workflow mit einer benutzerdefinierten Identity Broker-Anwendung\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/enterprise-authentication-with-identity-broker-application.diagram.png)


Dieses Szenario hat folgende Attribute:
+ Die Identity Broker-Anwendung hat die Berechtigung, auf die STS-API (Security Token Service) von IAM zuzugreifen, um temporäre Sicherheitsanmeldeinformationen zu erstellen.
+ Die Identity Broker-Anwendung kann überprüfen, ob die Mitarbeiter im vorhandenen Authentifizierungssystem authentifiziert sind.
+ Benutzer können eine temporäre URL abrufen, über die sie auf die AWS Managementkonsole zugreifen können (was als Single Sign-On bezeichnet wird).

Weitere Informationen zum Erstellen von temporären Sicherheitsanmeldeinformationen finden Sie unter [AWS STS Referenzen vergleichen](id_credentials_sts-comparison.md). Weitere Informationen zu SAML-Verbundprinzipalen, die Zugriff auf die AWS Management Console erhalten, finden Sie unter. [Aktivieren des Zugriffs von SAML 2.0-Verbundprinzipalen auf AWS-Managementkonsole](id_roles_providers_enable-console-saml.md)

# Erstellung einer IAM-Rolle
<a name="id_roles_create"></a>

Um eine Rolle zu erstellen, können Sie die AWS-Managementkonsole AWS CLI, die Tools für Windows oder die PowerShell IAM-API verwenden.

Wenn Sie die verwenden AWS-Managementkonsole, führt Sie ein Assistent durch die Schritte zum Erstellen einer Rolle. Der Assistent hat leicht unterschiedliche Schritte, je nachdem, ob Sie eine Rolle für einen AWS Dienst, für einen oder für einen AWS-Konto SAML- oder OIDC-Verbundprinzipal erstellen.

**Rollen für IAM-Benutzer**  
Erstellen Sie diese Rolle, um Berechtigungen innerhalb Ihrer Rollen AWS-Konto oder an Rollen zu delegieren, die in anderen Rollen definiert sind, die Ihnen gehören. AWS-Konten Ein Benutzer in einem Konto kann zu einer Rolle in demselben oder einem anderen Konto wechseln. Während die Rolle verwendet wird, können die Benutzer nur die Aktionen durchführen und auf die Ressourcen zugreifen, die von der Rolle zugelassen sind. Die ursprünglichen Berechtigungen der Benutzer sind ausgesetzt. Wenn der Benutzer die Rolle verlässt, werden die ursprünglichen Benutzerberechtigungen wiederhergestellt.

Weitere Informationen finden Sie unter [Erstellen einer Rolle zum Erteilen von Berechtigungen an einen IAM-Benutzer](id_roles_create_for-user.md).

Weitere Informationen zum Erstellen von Rollen für den kontenübergreifenden Zugriff finden Sie unter [Rolle mithilfe benutzerdefinierter Vertrauensrichtlinien erstellen](id_roles_create_for-custom.md).

**Rollen für Dienste AWS**  
Erstellen Sie diese Rolle, um Berechtigungen an einen Service zu delegieren, der in Ihrem Namen Aktionen ausführen kann. Eine [Servicerolle](id_roles.md#iam-term-service-role), die Sie an einen Service übergeben, muss über eine IAM-Richtlinie mit den Berechtigungen verfügen, die es dem Service ermöglichen, mit diesem Service verbundene Aktionen auszuführen. Für jeden AWS -Service werden unterschiedliche Berechtigungen benötigt.

Weitere Informationen zum Erstellen von Servicerollen finden Sie unter [Erstellen Sie eine Rolle, um Berechtigungen an einen AWS Dienst zu delegieren](id_roles_create_for-service.md).

Weitere Informationen zum Erstellen serviceverknüpfter Rollen finden Sie unter [Erstellen einer serviceverknüpften Rolle](id_roles_create-service-linked-role.md).

**Rollen für den Identitätsverbund**  
Erstellen Sie diese Rolle, um Berechtigungen an Benutzer zu delegieren, die bereits über Identitäten außerhalb von AWS verfügen. Wenn Sie einen -Identitätsanbieter verwenden, müssen Sie keinen eigenen Anmeldecode schreiben oder eigene Benutzeridentitäten verwalten. Ihre externen Benutzer melden sich über einen IdP an, und Sie können diesen externen Identitäten Berechtigungen zur Nutzung von AWS Ressourcen in Ihrem Konto erteilen. Identitätsanbieter tragen zur Sicherheit Ihres AWS Kontos bei, da Sie keine langfristigen Sicherheitsanmeldedaten wie Zugriffsschlüssel verteilen oder in Ihre Anwendung einbetten müssen.

Weitere Informationen finden Sie unter [Erstellen einer Rolle für einen externen Identitätsanbieter](id_roles_create_for-idp.md).

# Erstellen einer Rolle zum Erteilen von Berechtigungen an einen IAM-Benutzer
<a name="id_roles_create_for-user"></a>

Sie können IAM-Rollen verwenden, um Zugriff auf Ihre AWS Ressourcen zu gewähren. *Mit IAM-Rollen können Sie Vertrauensbeziehungen zwischen Ihrem vertrauenswürdigen Konto und anderen * AWS vertrauenswürdigen* Konten einrichten.* Das vertrauende Konto besitzt die Ressource, auf die zugegriffen werden soll, und das vertrauenswürdige Konto enthält die Benutzer, die Zugriff auf die Ressource erhalten müssen. Es ist jedoch möglich, dass ein anderes Konto eine Ressource in Ihrem Konto besitzt. Beispielsweise kann das Vertrauenskonto dem vertrauenswürdigen Konto erlauben, neue Ressourcen zu erstellen, z. B. neue Objekte in einem Amazon-S3-Bucket. In diesem Fall besitzt das Konto, das die Ressource erstellt, die Ressource und steuert, wer auf sie zugreifen kann.

Nachdem Sie die Vertrauensstellung erstellt haben, kann ein IAM-Benutzer oder eine Anwendung aus dem vertrauenswürdigen Konto den API-Vorgang AWS -Security-Token-Service (AWS STS) [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)verwenden. Dieser Vorgang stellt temporäre Sicherheitsanmeldedaten bereit, die den Zugriff auf AWS Ressourcen in Ihrem Konto ermöglichen.

Sie können die beiden Konten steuern oder das Konto mit den Benutzern kann von einem Drittanbieter gesteuert werden. Wenn es sich bei dem anderen Konto mit den Benutzern um ein Konto handelt, AWS-Konto das Sie nicht kontrollieren, können Sie das `externalId` Attribut verwenden. Die externe ID kann ein beliebiges Wort oder eine beliebige Zahl sein, das bzw. die zwischen Ihnen und dem Administrator des Drittanbieter-Kontos vereinbart wurde. Durch diese Option wird der Vertrauensrichtlinie automatisch eine Bedingung hinzugefügt, mit der der Benutzer die Rolle nur dann übernehmen kann, wenn die Anforderung die richtige `sts:ExternalID` enthält. Weitere Informationen finden Sie unter [Zugriff auf AWS-Konten Eigentum Dritter](id_roles_common-scenarios_third-party.md).

Weitere Informationen zur Verwendung von Rollen zum Delegieren von Berechtigungen finden Sie unter [Rollenbegriffe und -konzepte](id_roles.md#id_roles_terms-and-concepts). Informationen zur Verwendung einer Servicerolle zum Erlauben des Zugriffs auf Ressourcen in Ihrem Konto durch Services finden Sie unter [Erstellen Sie eine Rolle, um Berechtigungen an einen AWS Dienst zu delegieren](id_roles_create_for-service.md).

## Erstellen einer IAM-Rolle (Konsole)
<a name="roles-creatingrole-user-console"></a>

Sie können das verwenden AWS-Managementkonsole , um eine Rolle zu erstellen, die ein IAM-Benutzer übernehmen kann. Gehen Sie beispielsweise davon aus, dass Ihr Unternehmen über mehrere Systeme verfügt AWS-Konten , um eine Entwicklungsumgebung von einer Produktionsumgebung zu isolieren. Allgemeine Informationen zum Erstellen einer Rolle, mit der Benutzer im Entwicklungskonto auf Ressourcen in der Produktionsumgebung zugreifen können, finden Sie unter [Beispielszenario mit getrennten Entwicklungs- und Produktionskonten](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example).

**Mindestberechtigungen**  
Für die folgenden Schritte sind mindestens folgende IAM-Berechtigungen erforderlich:  
`access-analyzer:ValidatePolicy`
`iam:AttachRolePolicy`
`iam:CreatePolicy`
`iam:CreateRole`
`iam:GetAccountSummary`
`iam:GetPolicy`
`iam:GetPolicyVersion`
`iam:GetRole`
`iam:ListAccountAliases`
`iam:ListAttachedRolePolicies`
`iam:ListOpenIDConnectProviders`
`iam:ListPolicies`
`iam:ListRolePolicies`
`iam:ListRoles`
`iam:ListRoleTags`
`iam:ListSAMLProviders`

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

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Klicken Sie im Navigationsbereich der Konsole auf **Roles (Rollen)** und wählen Sie dann **Create role (Rolle erstellen)**.

1. Wählen Sie den Rollentyp **AWS-Konto**.

1. Um eine Rolle für Ihr Konto zu erstellen, wählen Sie **This account** (Dieses Konto) aus. Um eine Rolle für ein anderes Konto zu erstellen, wählen Sie **Anderes AWS-Konto** und geben Sie die **Konto-ID** ein, der Sie Zugriff auf Ihre Ressourcen gewähren möchten.

   Der Administrator des angegebenen Kontos kann die Berechtigung erteilen, diese Rolle für alle IAM-Benutzer in diesem Konto zu übernehmen. Hierzu fügt der Administrator eine Richtlinie an den Benutzer oder eine Gruppe an, mit der die Berechtigung für die Aktion `sts:AssumeRole` gewährt wird. Diese Richtlinie muss den ARN der Rolle als `Resource` angeben. 

1. Wenn Sie Benutzern Berechtigungen von einem Konto gewähren, das Sie nicht kontrollieren, und die Benutzer diese Rolle programmgesteuert übernehmen, wählen Sie **Require external ID** (Externe ID fordern). Die externe ID kann ein beliebiges Wort oder eine beliebige Zahl sein, das bzw. die zwischen Ihnen und dem Administrator des Drittanbieter-Kontos vereinbart wurde. Durch diese Option wird der Vertrauensrichtlinie automatisch eine Bedingung hinzugefügt, mit der der Benutzer die Rolle nur dann übernehmen kann, wenn die Anforderung die richtige `sts:ExternalID` enthält. Weitere Informationen finden Sie unter [Zugriff auf AWS-Konten Eigentum Dritter](id_roles_common-scenarios_third-party.md).
**Wichtig**  
Wenn Sie diese Option wählen, wird der Zugriff auf die Rolle nur über die AWS CLI Tools für Windows oder die PowerShell AWS API eingeschränkt. Das liegt daran, dass Sie die AWS Konsole nicht verwenden können, um zu einer Rolle zu wechseln, deren Vertrauensrichtlinie eine `externalId` Bedingung enthält. Sie können jedoch diese Art des Zugriffs programmgesteuert erstellen, indem Sie mithilfe des relevanten SDK ein Skript oder eine Anwendung schreiben. Weitere Informationen hierzu und ein Beispielskript finden Sie unter [How to Enable Cross-Account Access to the AWS-Managementkonsole](https://aws.amazon.com/blogs/security/how-to-enable-cross-account-access-to-the-aws-management-console) im Blog zur AWS -Sicherheit.

1. Wenn Sie die Rolle auf Benutzer beschränken möchten, die sich über Multifaktor-Authentifizierung (MFA) anmelden, wählen Sie **Require MFA (MFA erforderlich)**. Dadurch wird eine Bedingung zur Vertrauensrichtlinie der Rolle hinzugefügt, mit der geprüft wird, ob eine MFA-Anmeldung vorliegt. Ein Benutzer, der die Rolle übernehmen möchte, muss sich mit einem temporären Einmalkennwort von einem konfigurierten MFA-Gerät aus anmelden. Benutzer ohne MFA-Authentifizierung können die Rolle nicht übernehmen. Weitere Informationen zu MFA finden Sie unter [AWS Multi-Faktor-Authentifizierung in IAM](id_credentials_mfa.md).

1. Wählen Sie **Weiter** aus.

1. IAM enthält eine Liste der AWS verwalteten und kundenverwalteten Richtlinien in Ihrem Konto. Wählen Sie die Richtlinie aus, die für die Berechtigungsrichtlinie verwendet werden soll, oder wählen **Create policy (Richtlinie erstellen)**, um eine neue Registerkarte im Browser zu öffnen und eine vollständig neue Richtlinie zu erstellen. Weitere Informationen finden Sie unter [Erstellen von IAM-Richtlinien](access_policies_create-console.md#access_policies_create-start). Nachdem Sie die Richtlinie erstellt haben, schließen Sie die Registerkarte und kehren zur ursprünglichen Registerkarte zurück. Aktivieren Sie das Kontrollkästchen neben den Berechtigungsrichtlinien, über die jeder, der die Rolle übernimmt, verfügen soll. Wenn Sie es vorziehen, zu diesem Zeitpunkt keine Richtlinien auszuwählen, können Sie sie der Rolle später hinzufügen. Standardmäßig hat eine Rolle keine Berechtigungen.

1. (Optional) Legen Sie eine [Berechtigungsgrenze](access_policies_boundaries.md) fest. Dies ist ein erweitertes Feature. 

   Öffnen Sie den Abschnitt **Set permissions boundary (Berechtigungsgrenze festlegen)** und wählen Sie **Use a permissions boundary to control the maximum role permissions (Eine Berechtigungsgrenze verwenden, um die maximalen Rollenberechtigungen zu steuern)**. Wählen Sie die Richtlinie aus, die für eine Berechtigungsgrenze verwendet werden soll.

1. Wählen Sie **Weiter** aus.

1. Geben Sie unter **Role name (Rollenname)** einen Namen für Ihre Rolle ein. Rollennamen müssen innerhalb Ihres AWS-Konto Unternehmens eindeutig sein. Wenn ein Rollenname in einer Richtlinie oder als Teil eines ARN verwendet wird, muss die Groß-/Kleinschreibung des Rollennamens beachtet werden. Wenn Kunden in der Konsole ein Rollenname angezeigt wird, beispielsweise während des Anmeldevorgangs, wird die Groß-/Kleinschreibung des Rollennamens nicht beachtet. Da verschiedene Entitäten möglicherweise auf die Rolle verweisen, können Sie den Namen der Rolle nach der Erstellung nicht mehr bearbeiten.

1. (Optional) Geben Sie im Feld **Description** (Beschreibung) eine Beschreibung für die neue Rolle ein.

1. Wählen Sie in den Abschnitten **Step 1: Select trusted entities** (Schritt 1: Vertrauenswürdige Entitäten auswählen) oder **Step 2: Add permissions** (Schritt 2: Berechtigungen hinzufügen) die Option **Edit** (Bearbeiten) aus, um die Anwendungsfälle und Berechtigungen für die Rolle zu bearbeiten. Sie werden zu den vorherigen Seiten zurückgeleitet, um die Änderungen vorzunehmen.

1. (Optional) Fügen Sie der Rolle Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare anfügen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Tags für AWS Identity and Access Management Ressourcen](id_tags.md).

1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.
**Wichtig**  
Dies ist allerdings nur der erste Teil der erforderlichen Konfiguration. Sie müssen auch einzelnen Benutzern in den vertrauenswürdigen Konten die Berechtigung geben, in die Rolle in der Konsole zu wechseln oder die Rolle programmgesteuert zu übernehmen. Weitere Informationen zu diesem Schritt finden Sie unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).

------

## Erstellen einer IAM-Rolle (AWS CLI)
<a name="roles-creatingrole-user-cli"></a>

Das Erstellen einer Rolle aus dem AWS CLI umfasst mehrere Schritte. Wenn Sie die Konsole verwenden, um eine Rolle zu erstellen, werden viele der Schritte für Sie erledigt, aber mit der müssen AWS CLI Sie jeden Schritt explizit selbst ausführen. Sie müssen die Rolle erstellen und ihr dann eine Berechtigungsrichtlinie zuweisen. Optional können Sie auch die [Berechtigungsgrenze](access_policies_boundaries.md) für Ihre Rolle festlegen.

**So erstellen Sie eine Rolle für kontoübergreifenden Zugriff (AWS CLI)**

1. Erstellen Sie eine Rolle: [aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)

1. Fügen Sie der Rolle eine Richtlinie für verwaltete Berechtigungen hinzu: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html)

    oder

   Erstellen Sie eine Inline-Berechtigungsrichtlinie für die Rolle: [aws](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html) iam put-role-policy

1. (Optional) Fügen Sie der Rolle benutzerdefinierte Attribute durch Zuweisen von Tags hinzu: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Weitere Informationen finden Sie unter [Verwaltung von Tags in IAM-Rollen (AWS CLI oder AWS API)](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. (Optional) Legen Sie die [Berechtigungsgrenze](access_policies_boundaries.md) für die Rolle fest: [aws](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html) iam put-role-permissions-boundary

   Eine Berechtigungsgrenze bestimmt die maximalen Berechtigungen, die eine Rolle haben kann. Bei den Berechtigungsgrenzen handelt es sich um eine erweiterte AWS Funktion.

Das folgende Beispiel zeigt die ersten beiden und häufigsten Schritte zum Anlegen einer kontenübergreifenden Rolle in einer einfachen Umgebung. Dieses Beispiel erlaubt jedem Benutzer im `123456789012`-Konto, die Rolle zu übernehmen und den `example_bucket`-Amazon S3 Bucket anzuzeigen. In diesem Beispiel wird auch davon ausgegangen, dass Sie einen Client-Computer mit Windows verwenden und bereits die Befehlszeilenschnittstelle mit Ihren Konto-Anmeldeinformationen und der Region konfiguriert haben. Weitere Informationen finden Sie unter [Konfiguration der AWS Befehlszeilenschnittstelle](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

In diesem Beispiel nehmen Sie die folgende Vertrauensrichtlinie in den ersten Befehl auf, wenn Sie die Rolle erstellen. Diese Vertrauensrichtlinie gestattet Benutzern im `123456789012`-Konto, die Rolle unter Verwendung der `AssumeRole`-Operation anzunehmen, aber nur, wenn der Benutzer über die Parameter `SerialNumber` und `TokenCode` eine MFA-Authentifizierung bereitstellt. Weitere Informationen zu MFA finden Sie unter [AWS Multi-Faktor-Authentifizierung in IAM](id_credentials_mfa.md).

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

****  

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

------

**Wichtig**  
Wenn Ihr `Principal`-Element einen ARN für eine bestimmte IAM-Rolle oder einen bestimmten IAM-Benutzer enthält, wird dieser ARN beim Speichern der Richtlinie in eine eindeutige Auftraggeber-ID umgewandelt wird. Auf diese Weise wird das Risiko reduziert, dass jemand seine Berechtigungen durch Entfernen und Neuerstellen der Rolle oder des Benutzers erweitert. Normalerweise wird diese ID nicht in der Konsole angezeigt, da bei der Anzeige der Vertrauensrichtlinie auch eine Rückumwandlung zum ARN erfolgt. Wenn Sie die Rolle oder den Benutzer jedoch löschen, wird die Prinzipal-ID in der Konsole angezeigt, da sie nicht mehr einem ARN zugeordnet werden AWS kann. Wenn Sie also einen Benutzer oder eine Rolle löschen und neu erstellen, auf die beide im `Principal`-Element einer Vertrauensrichtlinie verwiesen wird, müssen Sie die Rolle bearbeiten, um den ARN zu ersetzen.

Wenn Sie den zweiten Befehl verwenden, müssen Sie der Rolle eine vorhandene verwaltete Richtlinie hinzufügen. Die folgende Berechtigungsrichtlinie erlaubt jedem, der die Rolle übernimmt, nur die Aktion `ListBucket` auf dem `example_bucket`-Amazon S3-Bucket durchzuführen.

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

****  

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

------

Um diese `Test-UserAccess-Role`-Rolle zu erstellen, müssen Sie zunächst die vorherige Vertrauensrichtlinie mit den Namen `trustpolicyforacct123456789012.json` im `policies`-Ordner in Ihrem lokalen `C:`-Laufwerk speichern. Speichern Sie dann die vorherige Berechtigungsrichtlinie als vom Kunden verwaltete Richtlinie in Ihrer AWS-Konto mit dem Namen`PolicyForRole`. Sie können dann die folgenden Befehle verwenden, um die Rolle zu erstellen und die verwaltete Richtlinie hinzuzufügen.

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

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

**Wichtig**  
Dies ist allerdings nur der erste Teil der erforderlichen Konfiguration. Sie müssen auch einzelnen Benutzern im vertrauenswürdigen Konto Berechtigungen zum Wechseln der Rolle erteilen. Weitere Informationen zu diesem Schritt finden Sie unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).

Nachdem Sie die Rolle erstellt und ihr Berechtigungen zur Ausführung von AWS Aufgaben oder zum Zugriff auf AWS Ressourcen erteilt haben, können alle Benutzer im `123456789012` Konto die Rolle übernehmen. Weitere Informationen finden Sie unter [Zu einer IAM-Rolle wechseln (AWS CLI)](id_roles_use_switch-role-cli.md).

## Eine IAM-Rolle (AWS API) erstellen
<a name="roles-creatingrole-user-api"></a>

Das Erstellen einer Rolle über die AWS API umfasst mehrere Schritte. Wenn Sie eine Rolle mithilfe der Konsole erstellen, werden viele Schritte automatisch abgeschlossen. In API müssen Sie diese Schritte jedoch manuell ausführen. Sie müssen die Rolle erstellen und ihr dann eine Berechtigungsrichtlinie zuweisen. Optional können Sie auch die [Berechtigungsgrenze](access_policies_boundaries.md) für Ihre Rolle festlegen.

**Um eine Rolle im Code (AWS API) zu erstellen**

1. Eine Rolle erstellen: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

   Für die Vertrauensrichtlinie der Rolle können Sie einen Dateispeicherort angeben.

1. Fügen Sie der Rolle eine verwaltete Berechtigungsrichtlinie hinzu: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

   oder

   Erstellen Sie eine Inline-Berechtigungsrichtlinie für die Rolle: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)
**Wichtig**  
Dies ist allerdings nur der erste Teil der erforderlichen Konfiguration. Sie müssen auch einzelnen Benutzern im vertrauenswürdigen Konto Berechtigungen zum Wechseln der Rolle erteilen. Weitere Informationen zu diesem Schritt finden Sie unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).

1. (Optional) Fügen Sie dem Benutzer benutzerdefinierte Attribute hinzu, indem Sie Tags anhängen: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Weitere Informationen finden Sie unter [Verwaltung von Tags für IAM-Benutzer (AWS CLI oder AWS API)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Optional) Legen Sie die [Berechtigungsgrenze](access_policies_boundaries.md) für die Rolle fest: [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Eine Berechtigungsgrenze bestimmt die maximalen Berechtigungen, die eine Rolle haben kann. Bei den Berechtigungsgrenzen handelt es sich um eine erweiterte AWS Funktion.

Nachdem Sie die Rolle erstellt und ihr Berechtigungen zur Ausführung von AWS Aufgaben oder zum Zugriff auf AWS Ressourcen erteilt haben, müssen Sie den Benutzern im Konto Berechtigungen erteilen, damit sie die Rolle übernehmen können. Weitere Informationen zum Übernehmen einer Rolle finden Sie unter [Zu einer IAM-Rolle (AWS API) wechseln](id_roles_use_switch-role-api.md).

## Erstellen einer IAM-Rolle (AWS CloudFormation)
<a name="roles_creatingrole-user-cloudformation"></a>

Informationen zum Erstellen einer IAM-Rolle in finden Sie in AWS CloudFormation der [Ressourcen- und Eigenschaftenreferenz](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html) sowie in den [Beispielen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#aws-resource-iam-role--examples) im *AWS CloudFormation Benutzerhandbuch*.

*Weitere Informationen zu IAM-Vorlagen finden Sie unter [AWS Identity and Access Management Vorlagenausschnitte im Benutzerhandbuch](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-iam.html). AWS CloudFormationAWS CloudFormation *

# Erstellen Sie eine Rolle, um Berechtigungen an einen AWS Dienst zu delegieren
<a name="id_roles_create_for-service"></a>

Für viele AWS Dienste müssen Sie Rollen verwenden, damit der Dienst in Ihrem Namen auf Ressourcen in anderen Diensten zugreifen kann. Eine Rolle, die ein Service übernimmt, um Aktionen in Ihrem Namen durchzuführen, wird als [Servicerolle](id_roles.md#iam-term-service-role) bezeichnet. Wenn eine Rolle einen speziellen Zweck für einen Service erfüllt, wird sie als [serviceverknüpfte Rolle](id_roles.md#iam-term-service-linked-role) kategorisiert. Informationen zu den Services, die serviceverknüpfte Rollen unterstützen, oder zu Services mit einer Form der temporären Anmeldeinformationen finden Sie unter [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md). Wenn Sie erfahren möchten, wie ein einzelner Service Rollen verwendet, wählen Sie den Servicenamen in der Tabelle aus, um die Dokumentation des jeweiligen Service anzuzeigen.

Beim Festlegen der `PassRole`-Berechtigung sollten Sie darauf achten, dass ein Benutzer keine Rolle übergibt, die über mehr Berechtigungen verfügt, als Sie dem Benutzer gewähren möchten. Zum Beispiel darf Alice möglicherweise keine Amazon-S3-Aktionen ausführen. Wenn Alice einem Service eine Rolle übergeben könnte, der Amazon-S3-Aktionen zulässt, könnte der Service bei der Ausführung des Auftrags Amazon-S3-Aktionen im Namen von Alice durchführen.

Informationen darüber, wie Rollen Ihnen das Delegieren von Berechtigungen erleichtern, finden Sie unter [Rollenbegriffe und -konzepte](id_roles.md#id_roles_terms-and-concepts).

## Servicerollen-Berechtigungen
<a name="id_roles_create_service-permissions"></a>

Sie müssen Berechtigungen konfigurieren, damit eine IAM-Entität (Benutzer oder Rolle) eine serviceverknüpfte Rolle erstellen oder bearbeiten kann.

**Anmerkung**  
Der ARN für eine serviceverknüpfte Rolle enthält einen Service-Prinzipal, der in den folgenden Richtlinien als `SERVICE-NAME.amazonaws.com` angegeben ist. Versuchen Sie nicht, den Service-Prinzipal zu erraten, da es auf Groß- und Kleinschreibung ankommt und das Format je nach AWS -Services variieren kann. Um den Dienstauftraggeber für einen Service zu sehen, sehen Sie sich seine serviceverknüpfte Rollendokumentation an.

**So erlauben Sie einer IAM-Entität das Erstellen einer bestimmten serviceverknüpften Rolle**

Fügen Sie die folgende Richtlinie der IAM-Entität hinzu, um die Servicerolle zu erstellen. Mit dieser Richtlinie können Sie eine Servicerolle für den angegebenen Service und mit einem bestimmten Namen erstellen. Anschließend können Sie verwaltete oder Inline-Richtlinien an die Rolle anfügen. 

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

****  

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

------

**So erlauben Sie einer IAM-Entität das Erstellen einer beliebigen Servicerolle**

AWS empfiehlt, dass Sie nur Administratorbenutzern das Erstellen von Servicerollen gestatten. Eine Person mit Berechtigungen zum Erstellen einer Rolle und zum Anfügen einer Richtlinie kann ihre eigenen Berechtigungen eskalieren. Erstellen Sie stattdessen eine Richtlinie, die es ihnen ermöglicht, nur die Rollen zu erstellen, die sie benötigen. Oder lassen Sie einen Administrator die Servicerolle in ihrem Namen erstellen.

Verwenden Sie die [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) AWS verwaltete Richtlinie, um eine Richtlinie anzuhängen, die es einem Administrator ermöglicht AWS-Konto, auf Ihre gesamte Richtlinie zuzugreifen.

**So erlauben Sie einer IAM-Entität das Bearbeiten einer bestimmten Servicerolle**

Fügen Sie die folgende Richtlinie der IAM-Entität hinzu, um die Servicerolle zu bearbeiten.

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

****  

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

------

**So erlauben Sie einer IAM-Entität das Löschen einer bestimmten Servicerolle**

Fügen Sie die folgende Anweisung der Berechtigungsrichtlinie für die IAM-Entität hinzu, um die angegebene Servicerolle zu löschen.

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

**So erlauben Sie einer IAM-Entität das Löschen einer beliebigen Servicerolle**

AWS empfiehlt, dass Sie nur Administratorbenutzern das Löschen von Servicerollen gestatten. Erstellen Sie stattdessen eine Richtlinie, mit der sie nur die Rollen löschen können, die sie benötigen, oder dass ein Administrator die Servicerolle in ihrem Namen löscht.

Verwenden Sie die [AdministratorAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AdministratorAccess) AWS verwaltete Richtlinie, um eine Richtlinie anzuhängen, die es einem Administrator ermöglicht AWS-Konto, auf Ihre gesamte Richtlinie zuzugreifen.

## Eine Rolle für einen AWS Dienst (Konsole) erstellen
<a name="roles-creatingrole-service-console"></a>

Sie können den verwenden AWS-Managementkonsole , um eine Rolle für einen Dienst zu erstellen. Da einige Services mehrere Servicerollen unterstützen, finden Sie in der [AWS -Dokumentation](https://docs.aws.amazon.com/) für Ihren Service Informationen dazu, welcher Anwendungsfall auszuwählen ist. Sie können erfahren, wie Sie der Rolle die erforderlichen Vertrauens- und Berechtigungsrichtlinien zuweisen, damit der Service die Rolle in Ihrem Namen zuordnen kann. Die Schritte, mit denen Sie die Berechtigungen für Ihre Rolle steuern können, hängen davon ab, wie der Service die Anwendungsfälle definiert und ob Sie eine servicegebundene Rolle anlegen.

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

**So erstellen Sie eine Rolle für eine AWS-Service (IAM-Konsole)**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Klicken Sie im Navigationsbereich der IAM-Konsole auf **Rollen**, und wählen Sie dann **Rolle erstellen**.

1. Wählen Sie für **Vertrauenswürdige Entität** die Option **AWS-Service** aus.

1. Wählen Sie unter **Service oder Anwendungsfall** einen Service und anschließend den Anwendungsfall aus. Die Anwendungsfälle werden vom Dienst so definiert, dass sie die Vertrauensrichtlinie beinhalten, die für den Dienst erforderlich ist.

1. Wählen Sie **Weiter** aus.

1. Bei **Berechtigungsrichtlinien** hängen die Optionen vom ausgewählten Anwendungsfall ab:
   + Wenn der Service die Berechtigungen für die Rolle definiert, können Sie keine Berechtigungsrichtlinien auswählen.
   + Wählen Sie aus einer begrenzten Anzahl von Berechtigungsrichtlinien.
   + Wählen Sie aus allen Berechtigungsrichtlinien.
   + Wählen Sie keine Berechtigungsrichtlinien aus, erstellen Sie die Richtlinien, nachdem die Rolle erstellt wurde, und fügen Sie die Richtlinien dann der Rolle an.

1. (Optional) Legen Sie eine [Berechtigungsgrenze](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) fest. Dies ist ein erweitertes Feature, das für Servicerollen verfügbar ist, aber nicht für servicegebundene Rollen.

   1. Öffnen Sie den Abschnitt **Berechtigungsgrenze festlegen** und wählen Sie dann **Eine Berechtigungsgrenze verwenden, um die maximalen Rollenberechtigungen zu steuern** aus. 

      IAM enthält eine Liste der AWS verwalteten und kundenverwalteten Richtlinien in Ihrem Konto.

   1. Wählen Sie die Richtlinie aus, die für eine Berechtigungsgrenze verwendet werden soll.

1. Wählen Sie **Weiter** aus.

1. Für den **Rollennamen** hängen die Optionen vom Service ab:
   + Wenn der Name der Rolle durch den Service definiert wird, können Sie den Namen der Rolle nicht bearbeiten.
   + Wenn der Service ein Präfix für den Rollennamen definiert, können Sie ein optionales Suffix eingeben.
   + Wenn der Service den Rollennamen nicht definiert, können Sie der Rolle einen Namen geben.
**Wichtig**  
Beachten Sie beim Benennen einer Rolle Folgendes:  
Rollennamen müssen innerhalb Ihres AWS-Konto Unternehmens eindeutig sein und können nicht von Fall zu Fall eindeutig sein.  
Erstellen Sie beispielsweise keine Rollen mit dem Namen **PRODROLE** und **prodrole**. Wenn ein Rollenname in einer Richtlinie oder als Teil einer ARN verwendet wird, muss die Groß-/Kleinschreibung des Rollennamens beachtet werden. Wenn ein Rollenname den Kunden jedoch in der Konsole angezeigt wird, z. B. während des Anmeldevorgangs, wird die Groß-/Kleinschreibung des Rollennamens nicht beachtet.
Sie können den Namen der Rolle nach ihrer Erstellung nicht mehr bearbeiten, da andere Entitäten möglicherweise auf die Rolle verweisen.

1. (Optional) Geben Sie unter **Beschreibung** eine Beschreibung für die neue Rolle ein.

1. (Optional) Um die Anwendungsfälle und Berechtigungen für die Rolle zu bearbeiten, wählen Sie in den Abschnitten **Schritt 1: Vertrauenswürdige Entitäten auswählen** oder **Schritt 2: Berechtigungen hinzufügen** die Option **Bearbeiten**.

1. (Optional) Fügen Sie Tags als Schlüssel-Wert-Paare hinzu, um die Identifizierung, Organisation oder Suche nach der Rolle zu vereinfachen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Tags für AWS Identity and Access Management Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) im *IAM-Benutzerhandbuch*.

1. Prüfen Sie die Rolle und klicken Sie dann auf **Create Role (Rolle erstellen)**.

------

## Erstellen einer Rolle für einen Service (AWS CLI)
<a name="roles-creatingrole-service-cli"></a>

Das Erstellen einer Rolle aus dem AWS CLI umfasst mehrere Schritte. Wenn Sie die Konsole verwenden, um eine Rolle zu erstellen, werden viele der Schritte für Sie erledigt, aber mit der müssen AWS CLI Sie jeden Schritt explizit selbst ausführen. Sie müssen die Rolle erstellen und ihr dann eine Berechtigungsrichtlinie zuweisen. Wenn der Service, mit dem Sie arbeiten, Amazon EC2 ist, müssen Sie außerdem ein Instance-Profil erstellen und die Rolle diesem Profil hinzufügen. Optional können Sie auch die [Berechtigungsgrenze](access_policies_boundaries.md) für Ihre Rolle festlegen.

**Um eine Rolle für einen AWS Dienst aus dem zu erstellen AWS CLI**

1. Mit dem folgenden Befehl `[create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)` wird eine Rolle mit dem Namen *Test-Rolle* erstellt und ihr eine Vertrauensrichtlinie zugewiesen:

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

1. Fügen Sie der Rolle eine Richtlinie für verwaltete Berechtigungen hinzu: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html).

   Mit dem folgenden Befehl `attach-role-policy` wird beispielsweise die verwaltete AWS -Richtlinie namens `ReadOnlyAccess` an die IAM-Rolle namens `ReadOnlyRole` angehängt:

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

    oder

   Erstellen Sie eine Inline-Berechtigungsrichtlinie für die Rolle: [aws](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html) iam put-role-policy

   Informationen zum Hinzufügen einer Inline-Berechtigungsrichtlinie finden Sie im folgenden Beispiel:

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

1. (Optional) Fügen Sie der Rolle benutzerdefinierte Attribute durch Zuweisen von Tags hinzu: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Weitere Informationen finden Sie unter [Verwaltung von Tags in IAM-Rollen (AWS CLI oder AWS API)](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. (Optional) Legen Sie die [Berechtigungsgrenze](access_policies_boundaries.md) für die Rolle fest: [aws](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html) iam put-role-permissions-boundary

   Eine Berechtigungsgrenze bestimmt die maximalen Berechtigungen, die eine Rolle haben kann. Bei den Berechtigungsgrenzen handelt es sich um eine erweiterte AWS Funktion.

Wenn Sie die Rolle mit Amazon EC2 oder einem anderen AWS Service verwenden möchten, der Amazon EC2 verwendet, müssen Sie die Rolle in einem Instanzprofil speichern. Ein Instance-Profil ist ein Container für eine Rolle, der beim Start an eine Amazon EC2-Instance angefügt werden kann. Ein Instance-Profil kann nur eine -Rolle enthalten und dieses Limit kann nicht erhöht werden. Wenn Sie die Rolle mithilfe von erstellen AWS-Managementkonsole, wird das Instance-Profil mit demselben Namen wie die Rolle für Sie erstellt. Weitere Informationen zu Instance-Profilen finden Sie unter [Verwendung von Instance-Profilen](id_roles_use_switch-role-ec2_instance-profiles.md). Informationen zum Starten einer EC2-Instance mit einer Rolle finden Sie unter [Steuern des Zugriffs auf Amazon-EC2-Ressourcen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances) im *Amazon-EC2-Benutzerhandbuch*.

**So erstellen Sie ein Instance-Profil und speichern die Rolle darin (AWS CLI)**

1. Erstellen Sie ein Instanzprofil: [aws iam create-instance-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html)

1. Fügen Sie die Rolle dem Instanzprofil hinzu: [aws add-role-to-instance iam](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html) -profile

Der folgende AWS CLI Beispiel-Befehlssatz veranschaulicht die ersten beiden Schritte zum Erstellen einer Rolle und zum Anhängen von Berechtigungen. Es zeigt auch die beiden Schritte zum Anlegen eines Instance-Profils und zum Hinzufügen der Rolle zum Profil. Diese Beispielvertrauensrichtlinie erlaubt dem Amazon EC2-Service, die Rolle zu übernehmen und den `example_bucket`–Amazon S3-Bucket anzuzeigen. In diesem Beispiel wird auch davon ausgegangen, dass Sie einen Client-Computer mit Windows ausführen und bereits die Befehlszeilenschnittstelle mit den Anmeldeinformationen und der Region für Ihr Konto konfiguriert haben. Weitere Informationen finden Sie unter [Konfiguration der AWS Befehlszeilenschnittstelle](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

In diesem Beispiel nehmen Sie die folgende Vertrauensrichtlinie in den ersten Befehl auf, wenn Sie die Rolle erstellen. Diese Vertrauensrichtlinie gestattet dem Amazon EC2-Service, die Rolle zu übernehmen. 

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

****  

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

------

Wenn Sie den zweiten Befehl verwenden, müssen Sie der Rolle eine Berechtigungsrichtlinie hinzufügen. Die folgende Beispiel-Berechtigungsrichtlinie gestattet der Rolle nur, die `ListBucket`-Aktion für den `example_bucket` Amazon S3-Bucket auszuführen.

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

****  

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

------

Um diese `Test-Role-for-EC2`-Rolle zu erstellen, müssen Sie zuvor die vorhergehende Vertrauensrichtlinie mit dem Namen `trustpolicyforec2.json` und die vorherige Berechtigungsrichtlinie mit dem Namen `permissionspolicyforec2.json` im `policies`-Verzeichnis Ihres lokalen `C:`-Laufwerks speichern. Mit den folgenden Befehlen können Sie dann die Rolle erstellen, die Richtlinie hinzufügen, das Instance-Profil erstellen und die Rolle dem Instance-Profil hinzufügen.

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

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

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

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

Wenn Sie die EC2-Instance starten, geben Sie den Namen des Instance-Profils auf der Seite „**Instanzdetails konfigurieren**“ an, wenn Sie die AWS Konsole verwenden. Wenn Sie den CLI-Befehl `aws ec2 run-instances` verwenden, legen Sie den `--iam-instance-profile`-Parameter fest.

## Eine Rolle für einen Dienst (AWS API) erstellen
<a name="roles-creatingrole-service-api"></a>

Das Erstellen einer Rolle über die AWS API umfasst mehrere Schritte. Wenn Sie eine Rolle mithilfe der Konsole erstellen, werden viele Schritte automatisch abgeschlossen. In API müssen Sie diese Schritte jedoch manuell ausführen. Sie müssen die Rolle erstellen und ihr dann eine Berechtigungsrichtlinie zuweisen. Wenn der Service, mit dem Sie arbeiten, Amazon EC2 ist, müssen Sie außerdem ein Instance-Profil erstellen und die Rolle diesem Profil hinzufügen. Optional können Sie auch die [Berechtigungsgrenze](access_policies_boundaries.md) für Ihre Rolle festlegen.

**Um eine Rolle für einen AWS Dienst (AWS API) zu erstellen**

1. Erstellen Sie eine Rolle: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

   Für die Vertrauensrichtlinie der Rolle können Sie einen Dateispeicherort angeben.

1. Fügen Sie der Rolle eine Richtlinie für verwaltete Berechtigungen hinzu: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

    oder

   Erstellen Sie eine Inline-Berechtigungsrichtlinie für die Rolle: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

1. (Optional) Fügen Sie dem Benutzer benutzerdefinierte Attribute hinzu, indem Sie Tags anhängen: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Weitere Informationen finden Sie unter [Verwaltung von Tags für IAM-Benutzer (AWS CLI oder AWS API)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Optional) Legen Sie die [Berechtigungsgrenze](access_policies_boundaries.md) für die Rolle fest: [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Eine Berechtigungsgrenze bestimmt die maximalen Berechtigungen, die eine Rolle haben kann. Bei den Berechtigungsgrenzen handelt es sich um eine erweiterte AWS Funktion.

Wenn Sie die Rolle mit Amazon EC2 oder einem anderen AWS Service verwenden möchten, der Amazon EC2 verwendet, müssen Sie die Rolle in einem Instanzprofil speichern. Ein Instance-Profil ist ein Container für eine Rolle. Jedes Instance-Profil kann nur eine Rolle enthalten und dieses Limit kann nicht erhöht werden. Wenn Sie die Rolle in der erstellen AWS-Managementkonsole, wird das Instance-Profil für Sie mit demselben Namen wie die Rolle erstellt. Weitere Informationen zu Instance-Profilen finden Sie unter [Verwendung von Instance-Profilen](id_roles_use_switch-role-ec2_instance-profiles.md). Informationen zum Starten einer Amazon-EC2-Instance mit einer Rolle finden Sie unter [Steuern des Zugriffs auf Amazon-EC2-Ressourcen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#UsingIAMrolesWithAmazonEC2Instances) im *Amazon-EC2-Benutzerhandbuch*. 

**Um ein Instanzprofil zu erstellen und die Rolle darin zu speichern (AWS API)**

1. Erstellen Sie ein Instanzprofil: [CreateInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html)

1. Fügen Sie die Rolle dem Instanzprofil hinzu: [AddRoleToInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html)

# Erstellen einer serviceverknüpften Rolle
<a name="id_roles_create-service-linked-role"></a>

Eine serviceverknüpfte Rolle ist ein spezieller Typ von IAM-Rolle, der direkt mit einem AWS -Service verknüpft ist. Dienstbezogene Rollen sind vom Dienst vordefiniert und enthalten alle Berechtigungen, die der Dienst benötigt, um andere AWS Dienste in Ihrem Namen aufzurufen. Der verknüpfte Service definiert auch, wie Sie eine serviceverknüpfte Rolle erstellen, ändern und löschen. Ein Service kann die Rolle automatisch erstellen oder löschen. Er kann Ihnen erlauben, die Rolle als Teil eines Assistenten oder Prozesses im Service zu erstellen, zu ändern oder zu löschen. Oder es kann erforderlich sein, dass Sie IAM zum Erstellen oder Löschen der Rolle verwenden. Unabhängig von der Methode erleichtern serviceverknüpfte Rollen den Prozess der Einrichtung eines Services, da Sie dem Service keine manuellen Berechtigungen für die Ausführung von Aktionen in Ihrem Namen hinzufügen müssen.

**Anmerkung**  
Denken Sie daran, dass sich Servicerollen von serviceverknüpften Rollen unterscheiden. Eine Servicerolle ist eine [IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html), die ein Service annimmt, um Aktionen in Ihrem Namen auszuführen. Ein IAM-Administrator kann eine Servicerolle innerhalb von IAM erstellen, ändern und löschen. Weitere Informationen finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen AWS-Service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) im *IAM-Benutzerhandbuch*. Eine dienstbezogene Rolle ist eine Art von Servicerolle, die mit einer verknüpft ist. AWS-Service Der Service kann die Rolle übernehmen, um eine Aktion in Ihrem Namen auszuführen. Dienstbezogene Rollen werden in Ihrem Dienst angezeigt AWS-Konto und gehören dem Dienst. Ein IAM-Administrator kann die Berechtigungen für Service-verknüpfte Rollen anzeigen, aber nicht bearbeiten. 

Der verknüpfte Service definiert die Berechtigungen seiner serviceverknüpften Rollen. Sofern keine andere Konfiguration festgelegt wurde, kann nur dieser Service die Rollen zuordnen. Die definierten Berechtigungen umfassen die Vertrauens- und Berechtigungsrichtlinie. Diese Berechtigungsrichtlinie kann keinen anderen IAM-Entitäten zugewiesen werden.

Bevor Sie die Rollen löschen können, müssen Sie zunächst die zugehörigen Ressourcen löschen. So wird sichergestellt, dass Sie nicht versehentlich die Berechtigung für den Zugriff auf die Ressourcen entfernen. 

**Tipp**  
Informationen darüber, welche Services die Verwendung von serviceverknüpften Rollen unterstützen, finden Sie unter [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md). Suchen Sie nach den Services, für die **Ja** in der Spalte **Serviceverknüpfte Rolle** angegeben ist. Wählen Sie über einen Link **Ja** aus, um die Dokumentation zu einer serviceverknüpften Rolle für diesen Service anzuzeigen.

## Berechtigungen von serviceverknüpften Rollen
<a name="service-linked-role-permissions"></a>

Sie müssen Berechtigungen für eine IAM-Entität konfigurieren (z. B. Benutzer oder Rolle), damit der Benutzer eine serviceverknüpfte Rolle erstellen oder bearbeiten kann.

**Anmerkung**  
Der ARN für eine serviceverknüpfte Rolle enthält einen Dienstauftraggeber, der in den nachfolgenden Richtlinien als `SERVICE-NAME.amazonaws.com` angegeben ist. Versuchen Sie nicht, den Dienstprinzipal zu erraten, da er zwischen Groß- und Kleinschreibung unterscheidet und das Format je nach AWS Dienst variieren kann. Um den Dienstauftraggeber für einen Service zu sehen, sehen Sie sich seine serviceverknüpfte Rollendokumentation an.

**So erlauben Sie einer IAM-Entität das Erstellen einer bestimmten serviceverknüpften Rolle**

Fügen Sie die folgende Richtlinie der IAM-Entität hinzu, um die serviceverknüpfte Rolle zu erstellen.

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

****  

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

------

**So erlauben Sie einer IAM-Entität das Erstellen einer beliebigen serviceverknüpften Rolle**

Fügen Sie die folgende Anweisung der Berechtigungsrichtlinie für die IAM-Entität hinzu, um eine serviceverknüpfte Rolle oder eine beliebige Servicerolle zu erstellen, die die benötigten Richtlinien enthält. Diese Richtlinienanweisung gewährt der IAM-Entität nicht, der Rolle eine Richtlinie anzufügen.

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

**So erlauben Sie einer IAM-Entität das Bearbeiten der Beschreibung von beliebigen Servicerollen**

Fügen Sie die folgende Anweisung der Berechtigungsrichtlinie für die IAM-Entität hinzu, um die Beschreibung einer serviceverknüpften Rolle oder einer beliebigen Servicerolle zu bearbeiten.

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

**So erlauben Sie einer IAM-Entität das Löschen einer bestimmten serviceverknüpften Rolle**

Fügen Sie die folgende Anweisung der Berechtigungsrichtlinie für die IAM-Entität hinzu, die die serviceverknüpfte Rolle löschen soll.

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

**So erlauben Sie einer IAM-Entität das Löschen einer beliebigen serviceverknüpften Rolle**

Fügen Sie die folgende Anweisung der Berechtigungsrichtlinie für die IAM-Entität hinzu, die eine serviceverknüpfte Rolle löschen muss, aber keine Servicerolle.

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

**So erlauben Sie einer IAM-Entität, eine vorhandene Rolle den Service zu übergeben**

Bei einigen AWS Diensten können Sie eine bestehende Rolle an den Dienst übergeben, anstatt eine neue dienstbezogene Rolle zu erstellen. Um dies zu tun, benötigt ein Benutzer Berechtigungen für das *Übergeben der Rolle* an den Service. Fügen Sie die folgende Anweisung der Berechtigungsrichtlinie für die IAM-Entität hinzu, die eine Rolle übergeben soll. Diese Richtlinienanweisung ermöglicht außerdem der Entität, eine Liste der Rollen anzuzeigen, aus denen sie die zu übergebende Rolle auswählen kann. Weitere Informationen finden Sie unter [Erteilen Sie einem Benutzer die Erlaubnis, eine Rolle an einen AWS Dienst zu übergeben](id_roles_use_passrole.md).

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

## Indirekte Berechtigungen mit serviceverknüpfte Rollen
<a name="create-service-linked-role-permissions-transfer"></a>

Die Berechtigungen einer serviceverknüpften Rolle können indirekt auf andere Benutzer und Rollen übertragen werden. Wenn eine dienstverknüpfte Rolle von einem AWS Dienst verwendet wird, kann diese dienstverknüpfte Rolle ihre eigenen Berechtigungen verwenden, um andere Dienste aufzurufen. AWS Das bedeutet, dass Benutzer und Rollen mit Berechtigungen zum Aufrufen eines Services, der eine serviceverknüpfte Rolle verwendet, möglicherweise indirekten Zugriff auf Services haben, auf die über diese serviceverknüpfte Rolle zugegriffen werden kann.

Wenn Sie beispielsweise eine Amazon-RDS-DB-Instance erstellen, wird automatisch eine [serviceverknüpfte Rolle für RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAM.ServiceLinkedRoles.html) erstellt, falls noch keine vorhanden ist. Diese servicebezogene Rolle ermöglicht es RDS, Amazon EC2, Amazon SNS, Amazon CloudWatch Logs und Amazon Kinesis in Ihrem Namen aufzurufen. Wenn Sie Benutzern und Rollen in Ihrem Konto erlauben, RDS-Datenbanken zu ändern oder zu erstellen, können sie möglicherweise indirekt mit Amazon EC2-, Amazon SNS-, Amazon CloudWatch Logs-Protokollen und Amazon Kinesis Kinesis-Ressourcen interagieren, indem sie RDS aufrufen, da RDS seine dienstbezogene Rolle für den Zugriff auf diese Ressourcen verwenden würde.

### Methoden zum Erstellen einer serviceverknüpfte Rolle
<a name="create-service-linked-role"></a>

Die Vorgehensweise zum Erstellen einer serviceverknüpften Rolle hängt vom Service ab. In einigen Fällen müssen Sie die serviceverknüpfte Rolle nicht manuell erstellen. Wenn Sie beispielsweise eine bestimmte Aktion (z. B. das Erstellen einer Ressource) im Service durchführen, erstellt der Service die serviceverknüpfte Rolle eventuell für Sie. Wenn Sie über einen Service verwenden, bevor dieser serviceverknüpfte Rollen unterstützt, hat der Service die Rolle eventuell bereits automatisch in Ihrem Konto erstellt. Weitere Informationen hierzu finden Sie unter [In meinem AWS Konto wurde eine neue Rolle angezeigt](troubleshoot_roles.md#troubleshoot_roles_new-role-appeared).

In anderen Fällen unterstützt der Service möglicherweise das manuelle Erstellen einer serviceverknüpften Rolle mit der Servicekonsole, einer API oder der CLI. Informationen darüber, welche Services die Verwendung von serviceverknüpften Rollen unterstützen, finden Sie unter [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md). Suchen Sie nach den Services, für die **Ja** in der Spalte **Serviceverknüpfte Rolle** angegeben ist. Um zu erfahren, ob der Service das Erstellen der serviceverknüpften Rolle unterstützt, wählen Sie den Link **Yes** aus, um die Dokumentation zur serviceverknüpften Rolle dieses Services anzuzeigen.

Wenn der Service das Erstellen der Rolle nicht unterstützt, können Sie IAM verwenden, um die serviceverknüpfte Rolle zu erstellen.

**Wichtig**  
Serviceverknüpfte Rollen werden Ihrem Limit für [IAM-Rollen in einem AWS-Konto](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html#reference_iam-quotas-entities) zugerechnet. Wenn Sie Ihr Limit erreicht haben, können Sie jedoch trotzdem serviceverknüpfte Rollen in Ihrem Konto erstellen. Nur serviceverknüpfte Rollen können das Limit überschreiten.

### Erstellen einer serviceverknüpften Rolle (Konsole)
<a name="create-service-linked-role-iam-console"></a>

Bevor Sie eine serviceverknüpfte Rolle in IAM erstellen, müssen Sie ermitteln, ob der verknüpfte Service serviceverknüpfte Rollen automatisch erstellt und ob Sie die Rolle über die Konsole, eine API oder die CLI des Services erstellen können.<a name="create-service-linked-role-iam-console"></a>

**So erstellen Sie eine serviceverknüpfte Rolle (Konsole)**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Wählen Sie im Navigationsbereich der IAM Console **Roles** (Rollen) aus. Wählen Sie anschließend **Create role** (Rolle erstellen) aus.

1. Wählen Sie den Rollentyp **AWS -Service**.

1. Wählen Sie den Anwendungsfall für den Service. Anwendungsfälle werden durch den Service definiert, damit die für den Service erforderliche Vertrauensrichtlinie enthalten ist. Wählen Sie anschließend **Weiter**.

1. Wählen Sie Berechtigungsrichtlinien aus, die Sie an die Rolle anfügen möchten. Je nach ausgewähltem Anwendungsfall führt der Service einen der folgenden Schritte aus:
   + Definieren der Berechtigungen für die Rolle.
   + Erlaubt Ihnen die Auswahl aus einem begrenzten Satz von Berechtigungen.
   + Erlaubt Ihnen die Auswahl aus beliebigen Berechtigungen.
   + Sie dürfen zu diesem Zeitpunkt noch keine Richtlinien auswählen. Erstellen Sie die Richtlinien später und fügen Sie diese dann an die Rolle an.

   Aktivieren Sie das Kontrollkästchen neben der Richtlinie, die der Rolle die gewünschten Berechtigungen zuweist, und wählen Sie dann **Weiter** aus. 
**Anmerkung**  
Die festgelegten Berechtigungen sind für alle Entitäten verfügbar, die die Rolle verwenden. Standardmäßig hat eine Rolle keine Berechtigungen.

1. Für **Role name (Rollenname)** werden die Anpassungsmöglichkeiten für den Rollennamen durch den Service festgelegt. Wenn der Service den Namen der Rolle definiert, kann diese Option nicht bearbeitet werden. In anderen Fällen kann der Service ein Präfix für die Rolle festlegen und Ihnen das Eingeben eines optionalen Suffixes erlauben.

   Geben Sie, wenn möglich, ein Suffix für den Rollennamen ein, das dem Standardnamen hinzugefügt wird. Dieses Suffix hilft Ihnen, den Zweck dieser Rolle zu identifizieren. Rollennamen müssen innerhalb Ihres AWS -Kontos eindeutig sein. Sie werden nicht nach Groß- und Kleinschreibung unterschieden. z. B. können Sie keine Rollen erstellen, die **<service-linked-role-name>\$1SAMPLE** bzw. **<service-linked-role-name>\$1sample** heißen. Da möglicherweise verschiedene Entitäten auf die Rolle verweisen, kann der Rollenname nach der Erstellung nicht bearbeitet werden.

1. (Optional:) Bearbeiten Sie für **Description** (Beschreibung) die Beschreibung der neuen serviceverknüpften Rolle.

1. Sie können während der Erstellung keine Tags an servicegebundene Rollen anfügen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Tags für AWS Identity and Access Management Ressourcen](id_tags.md).

1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.

### Erstellen einer serviceverknüpften Rolle (AWS CLI)
<a name="create-service-linked-role-iam-cli"></a>

Bevor Sie eine serviceverknüpfte Rolle in IAM erstellen, müssen Sie ermitteln, ob der verknüpfte Service serviceverknüpfte Rollen automatisch erstellt und ob Sie die Rolle über die CLI des Services erstellen können. Wenn die Service-CLI nicht unterstützt wird, verwenden Sie IAM-Befehle zum Erstellen einer serviceverknüpften Rolle mit der Vertrauensrichtlinie und den enthaltenen Richtlinien, die der Service benötigt, um die Rolle zuzuweisen.

**So erstellen Sie eine serviceverknüpfte Rolle (AWS CLI)**

Führen Sie den folgenden Befehl aus:

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

### Eine serviceverknüpfte Rolle (AWS API) erstellen
<a name="create-service-linked-role-iam-api"></a>

Bevor Sie eine serviceverknüpfte Rolle in IAM erstellen, müssen Sie ermitteln, ob der verknüpfte Service serviceverknüpfte Rollen automatisch erstellt und ob Sie die Rolle über die API des Services erstellen können. Wenn die Service-API nicht unterstützt wird, können Sie die AWS API verwenden, um eine dienstbezogene Rolle mit der Vertrauensrichtlinie und den Inline-Richtlinien zu erstellen, die der Dienst benötigt, um die Rolle zu übernehmen.

**Um eine dienstbezogene Rolle (AWS API) zu erstellen**

Verwenden Sie den [CreateServiceLinkedRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceLinkedRole.html)-API-Aufruf. Geben Sie in der Anforderung einen Servicenamen im Format `SERVICE_NAME_URL.amazonaws.com` an. 

Zum Erstellen der serviceverknüpften Rolle **Lex Bots** verwenden Sie z. B. `lex.amazonaws.com`.

# Erstellen einer Rolle für einen externen Identitätsanbieter
<a name="id_roles_create_for-idp"></a>

Sie können Identitätsanbieter verwenden, anstatt IAM-Benutzer in Ihrem AWS-Konto zu erstellen. Mit einem Identitätsanbieter (IdP) können Sie Ihre Benutzeridentitäten außerhalb von verwalten AWS und diesen externen Benutzeridentitäten Berechtigungen für den Zugriff auf AWS Ressourcen in Ihrem Konto erteilen. Weitere Informationen zu Verbund- und Identitätsanbietern finden Sie unter [Identitätsanbieter und Verbund zu AWS](id_roles_providers.md).

## Erstellen von Rollen für OIDC- und SAML-Verbundprinzipale (Konsole)
<a name="roles-creatingrole-federated-users-console"></a>

Die Vorgehensweise zur Erstellung einer Rolle hängt von den gewählten Drittanbietern ab:
+ Informationen zu OpenID Connect (OIDC) finden Sie unter [Rollen für OpenID-Connect-Verbund erstellen (Konsole)](id_roles_create_for-idp_oidc.md).
+ Weitere Informationen über SAML 2.0 finden Sie unter [Rollen für den SAML 2.0-Verbund erstellen (Konsole)](id_roles_create_for-idp_saml.md).

## Erstellen von Rollen für den Zugriff durch Verbundbenutzer (AWS CLI)
<a name="roles-creatingrole-identityprovider-cli"></a>

Die Schritte zum Erstellen einer Rolle für die unterstützten Identitätsanbieter (OIDC oder SAML) aus der AWS CLI sind identisch. Der Unterschied liegt im Inhalt der Vertrauensrichtlinie, die Sie in den notwendigen Schritten erstellen. Beginnen Sie mit den im Abschnitt **Voraussetzungen** beschriebenen Schritten für den verwendeten Anbietertyp:
+ Weitere Informationen über OIDC-Anbieter finden Sie unter [Voraussetzungen für das Erstellen einer Rolle für OIDC](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites).
+ Weitere Informationen über SAML-Anbieter finden Sie unter [Voraussetzungen für das Erstellen einer Rolle für SAML](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites).

Das Erstellen einer Rolle aus dem AWS CLI umfasst mehrere Schritte. Wenn Sie die Konsole verwenden, um eine Rolle zu erstellen, werden viele der Schritte für Sie erledigt, aber mit der müssen AWS CLI Sie jeden Schritt explizit selbst ausführen. Sie müssen die Rolle erstellen und ihr dann eine Berechtigungsrichtlinie zuweisen. Optional können Sie auch die [Berechtigungsgrenze](access_policies_boundaries.md) für Ihre Rolle festlegen.

**Um eine Rolle zu erstellen (AWS CLI)**

1. Erstellen Sie eine Rolle: [aws iam create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html)

1. Fügen Sie der Rolle eine Berechtigungsrichtlinie hinzu: [aws iam attach-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-role-policy.html)

    oder

   Erstellen Sie eine Inline-Berechtigungsrichtlinie für die Rolle: [aws](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html) iam put-role-policy

1. (Optional) Fügen Sie der Rolle benutzerdefinierte Attribute durch Zuweisen von Tags hinzu: [aws iam tag-role](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-role.html)

   Weitere Informationen finden Sie unter [Verwaltung von Tags in IAM-Rollen (AWS CLI oder AWS API)](id_tags_roles.md#id_tags_roles_procs-cli-api).

1. (Optional) Legen Sie die [Berechtigungsgrenze](access_policies_boundaries.md) für die Rolle fest: [aws](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html) iam put-role-permissions-boundary

   Eine Berechtigungsgrenze bestimmt die maximalen Berechtigungen, die eine Rolle haben kann. Bei den Berechtigungsgrenzen handelt es sich um eine erweiterte AWS Funktion.

Das folgende Beispiel zeigt die ersten beiden und häufigsten Schritte zum Anlegen einer Identitätsanbieter-Rolle in einer einfachen Umgebung. Dieses Beispiel erlaubt jedem Benutzer im `123456789012`-Konto, die Rolle zu übernehmen und den `example_bucket`-Amazon S3 Bucket anzuzeigen. In diesem Beispiel wird auch davon ausgegangen, dass Sie den AWS CLI auf einem Computer unter Windows ausführen und den bereits AWS CLI mit Ihren Anmeldeinformationen konfiguriert haben. Weitere Informationen finden Sie unter [Konfigurieren der AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).

Das folgende Beispiel einer Vertrauensrichtlinie ist für eine mobile Anwendung vorgesehen, wenn sich der Benutzer mit Amazon Cognito anmeldet. *us-east:12345678-ffff-ffff-ffff-123456*Stellt in diesem Beispiel die von Amazon Cognito zugewiesene Identitätspool-ID dar.

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

****  

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

------

Die folgende Berechtigungsrichtlinie erlaubt jedem, der die Rolle übernimmt, nur die Aktion `ListBucket` auf dem `example_bucket`-Amazon S3-Bucket durchzuführen.

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

****  

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

------

Um diese `Test-Cognito-Role`-Rolle zu erstellen, müssen Sie zuvor die vorhergehende Vertrauensrichtlinie mit dem Namen `trustpolicyforcognitofederation.json` und die vorherige Berechtigungsrichtlinie mit dem Namen `permspolicyforcognitofederation.json` im `policies`-Ordner Ihres lokalen `C:`-Laufwerks speichern. Sie können dann die folgenden Befehle verwenden, um die Rolle zu erstellen und die eingebundene Richtlinie hinzuzufügen.

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

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

## Eine Rolle für den Verbundzugriff (AWS API) erstellen
<a name="roles-creatingrole-identityprovider-api"></a>

Die Schritte zum Erstellen einer Rolle für die unterstützten Identitätsanbieter (OIDC oder SAML) aus der AWS CLI sind identisch. Der Unterschied liegt im Inhalt der Vertrauensrichtlinie, die Sie in den notwendigen Schritten erstellen. Beginnen Sie mit den im Abschnitt **Voraussetzungen** beschriebenen Schritten für den verwendeten Anbietertyp:
+ Weitere Informationen über OIDC-Anbieter finden Sie unter [Voraussetzungen für das Erstellen einer Rolle für OIDC](id_roles_create_for-idp_oidc.md#idp_oidc_Prerequisites).
+ Weitere Informationen über SAML-Anbieter finden Sie unter [Voraussetzungen für das Erstellen einer Rolle für SAML](id_roles_create_for-idp_saml.md#idp_saml_Prerequisites).

**Um eine Rolle (AWS API) zu erstellen**

1. Eine Rolle erstellen: [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)

1. Fügen Sie der Rolle eine Berechtigungsrichtlinie hinzu: [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)

    oder

   Erstellen Sie eine Inline-Berechtigungsrichtlinie für die Rolle: [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

1. (Optional) Fügen Sie dem Benutzer benutzerdefinierte Attribute hinzu, indem Sie Tags anhängen: [TagRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagRole.html)

   Weitere Informationen finden Sie unter [Verwaltung von Tags für IAM-Benutzer (AWS CLI oder AWS API)](id_tags_users.md#id_tags_users_procs-cli-api).

1. (Optional) Legen Sie die [Berechtigungsgrenze](access_policies_boundaries.md) für die Rolle fest: [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Eine Berechtigungsgrenze bestimmt die maximalen Berechtigungen, die eine Rolle haben kann. Bei den Berechtigungsgrenzen handelt es sich um eine erweiterte AWS Funktion.

# Rollen für OpenID-Connect-Verbund erstellen (Konsole)
<a name="id_roles_create_for-idp_oidc"></a>

Sie können die föderierten Identitätsanbieter von OpenID Connect (OIDC) verwenden, anstatt Benutzer in Ihrem zu erstellen AWS Identity and Access Management . AWS-Konto Mit einem Identitätsanbieter (IdP) können Sie Ihre Benutzeridentitäten außerhalb von verwalten AWS und diesen externen Benutzeridentitäten Berechtigungen für den Zugriff auf AWS Ressourcen in Ihrem Konto erteilen. Weitere Informationen zu Federation und IdPs finden Sie unter. [Identitätsanbieter und Verbund zu AWS](id_roles_providers.md)

## Voraussetzungen für das Erstellen einer Rolle für OIDC
<a name="idp_oidc_Prerequisites"></a>

Bevor Sie eine Rolle für den OIDC-Verbund erstellen können, müssen Sie zunächst die folgenden erforderlichen Schritte ausführen.<a name="oidc-prereqs"></a>

**So erstellen Sie eine Rolle für den OIDC-Verbund**

1. Melden Sie sich bei einem oder mehreren Services an, die eine Verbund-OIDC-Identität anbieten. Wenn Sie eine App erstellen, die Zugriff auf Ihre AWS Ressourcen benötigt, konfigurieren Sie Ihre App auch mit den Anbieterinformationen. Wenn Sie dies tun, erhalten Sie vom Anbieter eine Anwendungs- oder Zielgruppen-ID, die für Ihre Anwendung eindeutig ist. (Unterschiedliche Anbieter verwenden unterschiedliche Terminologie für diesen Prozess. In diesem Handbuch wird der Begriff *configure*, um Ihre App beim Anbieter zu identifizieren.) Sie können mehrere Anwendungen bei jedem Anbieter oder mehrere Anbieter mit einer einzigen Anwendung konfigurieren. Informationen zur Verwendung der Identitätsanbieter finden Sie im Folgendem:
   + [Login with Amazon-Entwicklerzentrum](https://login.amazon.com/)
   + [Add Facebook Login to Your App or Website](https://developers.facebook.com/docs/facebook-login/v2.1) auf der Facebook-Entwickler-Website.
   + [Verwenden von OAuth 2.0 für die Anmeldung (OpenID Connect)](https://developers.google.com/accounts/docs/OAuth2Login) auf der Google-Entwicklerseite.

1. <a name="idpoidcstep2"></a>Nachdem Sie die erforderlichen Informationen vom Identitätsanbieter erhalten haben, erstellen Sie einen Identitätsanbieter in IAM. Weitere Informationen finden Sie unter [OpenID Connect (OIDC)-Identitätsanbieter in IAM erstellen](id_roles_providers_create_oidc.md).
**Wichtig**  
Wenn Sie einen OIDC-Identitätsanbieter von Google, Facebook oder Amazon Cognito verwenden, erstellen Sie keinen separaten IAM-Identitätsanbieter in der AWS-Managementkonsole. Diese OIDC-Identitätsanbieter sind bereits integriert AWS und stehen Ihnen zur Nutzung zur Verfügung. Überspringen Sie diesen Schritt, und wechseln Sie im folgenden Schritt zum Erstellen neuer Rollen mit Ihrem Identitätsanbieter.

1. Bereiten Sie die Richtlinien für die Rolle vor, die von den über einen Identitätsanbieter authentifizierten Benutzern übernommen werden sollen. Wie bei jeder Rolle enthält eine Rolle für eine mobile App zwei Richtlinien. Eine ist die Vertrauensrichtlinie, die angibt, wer die Rolle übernehmen kann. Die andere ist die Berechtigungsrichtlinie, die die AWS -Aktionen und -Ressourcen angibt, auf die die mobile App Zugriff hat oder nicht.

   Für das Internet empfehlen wir IdPs, [Amazon Cognito](https://aws.amazon.com/cognito/) zur Verwaltung von Identitäten zu verwenden. In diesem Fall verwenden Sie eine Vertrauensrichtlinie, ähnlich wie in diesem Beispiel.

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

****  

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

------

   Ersetzen Sie `us-east-2:12345678-abcd-abcd-abcd-123456` durch die Identitätspool-ID, die Amazon Cognito Ihnen zuweist.

   Wenn Sie einen OIDC-IdP manuell konfigurieren, müssen Sie beim Erstellen der Vertrauensrichtlinie drei Werte verwenden, die sicherstellen, dass nur Ihre App die Rolle übernehmen kann:
   + Verwenden Sie für das Element `Action` die Aktion `sts:AssumeRoleWithWebIdentity`.
   + Verwenden Sie für das Element `Principal` die Zeichenfolge `{"Federated":providerUrl/providerArn}`.
     + Bei einigen gängigen OIDCs handelt es sich um IdPs eine URL. `providerUrl` Die folgenden Beispiele enthalten Methoden zur Angabe des Prinzips für einige häufig verwendete Methoden: IdPs

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

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

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

       `"Principal":{"Federated":"accounts.google.com"}`
     + Verwenden Sie für andere OIDC-Anbieter den Amazon-Ressourcenname (ARN) des OIDC-Identitätsanbieters, den Sie in [Step 2](#idpoidcstep2) erstellt haben, wie im folgenden Beispiel:

       `"Principal":{"Federated":"arn:aws:iam::123456789012:oidc-provider/server.example.com"}`
   + Verwenden Sie für das Element `Condition` eine Bedingung `StringEquals`, um die Berechtigungen einzuschränken. Testen Sie die Identitätspool-ID für Amazon Cognito) oder die App-ID für andere Anbieter. Die Identitätspool-ID sollte mit der App-ID übereinstimmen, die Sie bei der Konfiguration der App mit dem Identitätsanbieter erhalten haben. Diese Übereinstimmung zwischen den IDs stellt sicher, dass die Anfrage von Ihrer App stammt.
**Anmerkung**  
IAM-Rollen für Amazon Cognito-Identitätspools vertrauen darauf, dass der Service-Prinzipal `cognito-identity.amazonaws.com` die Rolle übernimmt. Rollen dieses Typs müssen mindestens einen Bedingungsschlüssel enthalten, um die Anzahl der Prinzipale einzuschränken, die die Rolle übernehmen können.  
Für Amazon-Cognito-Identitätspools, die [kontenübergreifende IAM-Rollen](access_policies-cross-account-resource-access.md) übernehmen, gelten zusätzliche Überlegungen. Die Vertrauensrichtlinien dieser Rollen müssen den Service-Prinzipal `cognito-identity.amazonaws.com` akzeptieren und den Bedingungsschlüssel `aud` enthalten, um die Rollenübernahme auf Benutzer aus Ihren vorgesehenen Identitätspools zu beschränken. Eine Richtlinie, die Amazon-Cognito-Identitätspools ohne diese Bedingung vertraut, birgt das Risiko, dass ein Benutzer aus einem nicht vorgesehenen Identitätspool die Rolle übernehmen kann. Weitere Informationen finden Sie unter [Vertrauensrichtlinien für IAM-Rollen in der grundlegenden (klassischen) Authentifizierung](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#trust-policies) im *Amazon-Cognito-Entwicklerhandbuch*.

     Erstellen Sie ein Bedingungselement ähnlich einem der folgenden Beispiele, je nach dem von Ihnen verwendeten Identitätsanbieter: 

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

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

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

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

     Verwenden Sie für OIDC-Anbieter die vollqualifizierte URL des OIDC-Identitätsanbieters mit dem Kontextschlüssel `aud` wie im folgenden Beispiel: 

     `"Condition": {"StringEquals": {"server.example.com:aud": "appid_from_oidc_idp"}}`
**Anmerkung**  
Die Werte für den Prinzipal in der Vertrauensrichtlinie für die Rolle sind spezifisch für einen Identitätsanbieter. Eine Rolle für OIDC kann nur einen Prinzipal angeben. Wenn sich Benutzer in einer mobilen App über mehrere Identitätsanbieter anmelden können, müssen Sie daher für jeden Identitätsanbieter den Sie unterstützen möchten, eine separate Rolle erstellen. Erstellen Sie separate Vertrauensrichtlinien für jeden Identitätsanbieter.

   Wenn sich ein Benutzer über eine mobile App bei Login with Amazon anmeldet, würde das folgende Beispiel einer Vertrauensrichtlinie gelten. Stellt im Beispiel die App-ID *amzn1.application-oa2-123456* dar, die Amazon zuweist, als Sie die App mithilfe von Login with Amazon konfiguriert haben.

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

****  

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

------

   Wenn ein Benutzer eine mobile App verwendet, um sich von Facebook aus anzumelden, würde das folgende Beispiel einer Vertrauensrichtlinie gelten. Stellt in diesem Beispiel die App-ID *111222333444555* dar, die Facebook zuweist.

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

****  

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

------

   Wenn ein Benutzer eine mobile App verwendet, um sich von Google aus anzumelden, würde das folgende Beispiel einer Vertrauensrichtlinie gelten. Stellt in diesem Beispiel die App-ID *666777888999000* dar, die Google zuweist.

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

****  

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

------

   Wenn ein Benutzer eine mobile App verwendet, um sich von Amazon Cognito aus anzumelden, würde das folgende Beispiel einer Vertrauensrichtlinie gelten. Stellt in diesem Beispiel die Identitätspool-ID *us-east:12345678-ffff-ffff-ffff-123456* dar, die Amazon Cognito zuweist.

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

****  

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

------

## Erstellen einer Rolle für OIDC
<a name="idp_oidc_Create"></a>

Nach dem Erstellen der vorbereitenden Schritte können Sie nun die Rolle in IAM erstellen. *Für anerkannte Shared OpenID Connect (OIDC) -Identitätsanbieter (IdPs) erfordert IAM eine explizite Bewertung bestimmter Ansprüche in JSON Web Tokens (JWTs), die als Identity-Provider-Kontrollen bezeichnet werden.* *Weitere Informationen darüber, welche IdPs OIDC über Steuerelemente für Identitätsanbieter verfügen, finden Sie unter.* [Identitätsanbieter-Kontrollen für gemeinsame OIDC-Anbieter](id_roles_providers_oidc_secure-by-default.md)

Im folgenden Verfahren wird beschrieben, wie Sie die Rolle für den OIDC-Verbund in der AWS-Managementkonsole erstellen. Informationen zum Erstellen einer Rolle über die AWS API AWS CLI oder finden Sie in den Verfahren unter. [Erstellen einer Rolle für einen externen Identitätsanbieter](id_roles_create_for-idp.md)

**Wichtig**  
Wenn Sie Amazon Cognito verwenden, verwenden Sie die Amazon-Cognito-Konsole, um die Rollen einzurichten. Verwenden Sie andernfalls zum Erstellen von Rollen für den OIDC-Verbund die IAM-Konsole.

**So erstellen Sie eine IAM-Rolle für den OIDC-Verbund**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie im Navigationsbereich **Rollen** und dann **Rolle erstellen**.

1. **Wählen Sie **Web-Identität** als vertrauenswürdigen Entitätstyp aus und klicken Sie auf Weiter**.

1. Wählen Sie für **Identity provider** (Identitätsanbieter), den Identitätsanbieter für Ihre Rolle: 
   + Wenn Sie eine Rolle für einen einzelnen Web-Identitätsanbieter erstellen, wählen Sie **Login with Amazon**, **Facebook** oder **Google**. 
**Anmerkung**  
Sie müssen für jeden Identitätsanbieter, den Sie unterstützen möchten, eine eigene Rolle erstellen.
   + Wenn Sie eine erweiterte Szenario-Rolle für Amazon Cognito erstellen möchten, wählen Sie **Amazon Cognito**. 
**Anmerkung**  
Sie müssen eine Rolle manuell erstellen, um sie mit Amazon Cognito zu verwenden, wenn Sie an einem erweiterten Szenario arbeiten. Andernfalls kann Amazon Cognito Rollen für Sie erstellen. Weitere Informationen zu Amazon Cognito finden Sie unter [Identitätspools (verbundene Identitäten)](https://docs.aws.amazon.com/cognito/latest/developerguide/external-identity-providers.html) im *Amazon-Cognito-Entwicklerhandbuch*. 
   + Wenn Sie eine Rolle für GitHub Actions erstellen möchten, müssen Sie zunächst den GitHub OIDC-Anbieter zu IAM hinzufügen. **Nachdem Sie den GitHub OIDC-Anbieter zu IAM hinzugefügt haben, wählen Sie token.actions.githubusercontent.com.** 
**Anmerkung**  
Informationen zur Konfiguration, dem OIDC-Anbieter als föderierte Identität AWS zu vertrauen GitHub, finden Sie unter [GitHub Dokumente — Konfiguration von OpenID Connect in](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services) Amazon Web Services. Informationen zu bewährten Methoden zur Beschränkung des Zugriffs für Rollen, die mit dem IAM-IdP für verknüpft sind GitHub, finden Sie [Konfiguration einer Rolle für den GitHub OIDC-Identitätsanbieter](#idp_oidc_Create_GitHub) auf dieser Seite.
   + Wenn Sie eine Rolle für HashiCorp Cloud Platform (HCP) Terraform erstellen möchten, müssen Sie zunächst den Terraform OIDC-Anbieter zu IAM hinzufügen. Nachdem Sie den Terraform-OIDC-Anbieter zu IAM hinzugefügt haben, rufen Sie **app.terraform.io** ab. 
**Wichtig**  
IAM-Rollen für HashiCorp Cloud Platform (HCP) Der Terraform OIDC-Anbieter muss den IAM-Bedingungsschlüssel,, in der Rollenvertrauensrichtlinie auswerten. `app.terraform.io:sub` Dieser Bedingungsschlüssel begrenzt, welche HCP Terraform-Organisationen, Projekte, Arbeitsbereiche oder Ausführungsphasen die Rolle übernehmen können. Ohne diesen Bedingungsschlüssel gewährt Ihre Vertrauensrichtlinie den Zugriff auf Ihre Rolle und AWS Ressourcen durch Identitäten außerhalb Ihrer Organisation, was nicht dem Prinzip der geringsten Rechte entspricht.   
Wenn Sie eine Rollenvertrauensrichtlinie für eine Rolle festlegen oder ändern, die dem HCP Terraform OIDC-Anbieter in Ihrem AWS Konto zugeordnet ist, aber den IAM-Bedingungsschlüssel `app.terraform.io:sub` nicht auswerten, erhalten Sie eine Fehlermeldung. Darüber hinaus lehnt AWS STS Autorisierungsanfragen ab, wenn Ihre Rollenvertrauensrichtlinie diesen Bedingungsschlüssel nicht auswertet.

1. Die angeforderten Informationen variieren je nach dem ausgewählten OIDC-Anbieter.
   + Geben Sie die Kennung für Ihre Anwendung ein. Die Marierung der Kennung ist abhängig von dem von Ihnen gewählten Anbieter:
     + Wenn Sie eine Rolle für Login with Amazon erstellen, geben Sie die App-ID in das Feld **Application ID** (Anwendungs-ID) ein.
     + Wenn Sie eine Rolle für Facebook erstellen, geben Sie die App-ID in das Feld **Application ID** (Anwendungs-ID) ein.
     + Wenn Sie eine Rolle für Google erstellen, geben Sie die App-ID in das Feld **Audience** (Zielgruppe) ein.
     + Wenn Sie eine Rolle für Amazon Cognito erstellen, geben Sie die ID des Identitäten-Pools, den Sie für Ihre Amazon-Cognito-Anwendungen erstellt haben, im Feld **Identity Pool ID** (Identitäten-Pool-ID) ein.
   + Wenn Sie eine Rolle für GitHub Actions erstellen möchten, geben Sie die folgenden Details ein:
     + Wählen Sie für **Audience (Zielgruppe)** `sts.amazonaws.com`.
     + Geben Sie für **GitHub Organisation** den Namen der GitHub Organisation ein. Der Name der GitHub Organisation ist erforderlich und muss alphanumerisch sein und Bindestriche (-) enthalten. Sie können keine Platzhalterzeichen (\$1 und?) verwenden im Namen der GitHub Organisation.
     + (Optional) Geben Sie für **GitHub Repository** den GitHub Repository-Namen ein. Wenn Sie keinen Wert angeben, wird standardmäßig ein Platzhalter (`*`) verwendet.
     + (Optional) Geben Sie für **GitHub Branch** den GitHub Branch-Namen ein. Wenn Sie keinen Wert angeben, wird standardmäßig ein Platzhalter (`*`) verwendet.
   + Wenn Sie eine Rolle für HashiCorp Cloud Platform (HCP) Terraform erstellen möchten, geben Sie die folgenden Details ein:
     + Wählen Sie für **Audience (Zielgruppe)** `aws.workload.identity`.
     + Geben Sie unter **Organisation** den Namen der Organisation eingeben. Sie können für alle Organisationen ein Platzhalterzeichen (`*`) angeben.
     + Geben Sie bei **Projekt** den Projektnamen ein. Sie können für alle Projekte ein Platzhalterzeichen (`*`) angeben.
     + Geben Sie unter **Arbeitsbereich** den Namen für den Arbeitsbereich ein. Sie können für alle Arbeitsbereiche ein Platzhalterzeichen (`*`) angeben.
     + Geben Sie für **Ausführungsphase** den Namen der Ausführungsphase ein. Sie können für alle Ausführungsphasen ein Platzhalterzeichen (`*`) angeben.

1. (Optional:) Wählen Sie unter **Bedingung (optional)** die Option **Bedingung hinzufügen** aus, um weitere Bedingungen zu erstellen, die erfüllt werden müssen, damit Benutzer Ihrer Anwendung die durch die Rolle erteilten Berechtigungen verwenden können. Sie können beispielsweise eine Bedingung hinzufügen, die den Zugriff auf AWS Ressourcen nur für eine bestimmte IAM-Benutzer-ID gewährt. Sie können Bedingungen auch der Vertrauensrichtlinie hinzufügen, nachdem die Rolle erstellt wurde. Weitere Informationen finden Sie unter [Rollenvertrauensrichtlinie aktualisieren](id_roles_update-role-trust-policy.md).

1. Überprüfen Sie Ihre OIDC-Informationen und klicken Sie dann auf **Weiter**.

1. IAM enthält eine Liste der AWS verwalteten und kundenverwalteten Richtlinien in Ihrem Konto. Wählen Sie die Richtlinie aus, die für die Berechtigungsrichtlinie verwendet werden soll, oder wählen Sie **Create policy** (Richtlinie erstellen), um eine neue Registerkarte im Browser zu öffnen und eine neue Richtlinie von Grund auf zu erstellen. Weitere Informationen finden Sie unter [Erstellen von IAM-Richtlinien](access_policies_create-console.md#access_policies_create-start). Nachdem Sie die Richtlinie erstellt haben, schließen Sie die Registerkarte und kehren zur ursprünglichen Registerkarte zurück. Aktivieren Sie das Kontrollkästchen neben den Berechtigungsrichtlinien, die OIDC-Benutzer haben sollen. Wenn Sie es vorziehen, zu diesem Zeitpunkt keine Richtlinien auszuwählen, können Sie sie der Rolle später hinzufügen. Standardmäßig hat eine Rolle keine Berechtigungen.

1. (Optional) Legen Sie eine [Berechtigungsgrenze](access_policies_boundaries.md) fest. Dies ist ein erweitertes Feature.

   Öffnen Sie den Abschnitt **Permissions boundary** (Berechtigungsgrenze) und wählen Sie **Use a permissions boundary to control the maximum role permissions** (Eine Berechtigungsgrenze verwenden, um die maximalen Rollen-Berechtigungen zu steuern). Wählen Sie die Richtlinie aus, die für eine Berechtigungsgrenze verwendet werden soll.

1. Wählen Sie **Weiter** aus.

1. Geben Sie für **Role name** (Rollenname) einen Rollennamen ein. Rollennamen müssen innerhalb Ihres AWS-Konto Unternehmens eindeutig sein. Dabei wird zwischen Groß- und Kleinschreibung nicht unterschieden. Zum Beispiel können Sie keine Rollen erstellen, die sowohl **PRODROLE** als auch **prodrole** heißen. Da andere AWS Ressourcen möglicherweise auf die Rolle verweisen, können Sie den Namen der Rolle nicht bearbeiten, nachdem Sie sie erstellt haben.

1. (Optional) Geben Sie im Feld **Description** (Beschreibung) eine Beschreibung für die neue Rolle ein.

1. Um die Anwendungsfälle und Berechtigungen für die Rolle zu bearbeiten, wählen Sie in den Abschnitten **Step 1: Select trusted entities** (Schritt 1: Vertrauenswürdige Entitäten auswählen) oder **Step 2: Add permissions** (Schritt 2: Berechtigungen hinzufügen) die Option **Edit** (Bearbeiten). 

1. (Optional) Wenn Sie der Rolle Metadaten hinzufügen möchten, fügen Sie Tags als Schlüssel-Wert-Paare an. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Tags für AWS Identity and Access Management Ressourcen](id_tags.md).

1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.

## Konfiguration einer Rolle für den GitHub OIDC-Identitätsanbieter
<a name="idp_oidc_Create_GitHub"></a>

Wenn Sie GitHub als OpenID Connect (OIDC) Identity Provider (IdP) verwenden, empfiehlt es sich, die Entitäten einzuschränken, die die dem IAM-IdP zugeordnete Rolle übernehmen können. Wenn Sie eine Bedingungserklärung in die Vertrauensrichtlinie aufnehmen, können Sie die Rolle auf eine bestimmte GitHub Organisation, ein Repository oder eine Branche beschränken. Sie können den Bedingungsschlüssel `token.actions.githubusercontent.com:sub` mit Bedingungsoperatoren für Zeichenfolgen verwenden, um den Zugriff einzuschränken. Wir empfehlen, die Bedingung auf eine bestimmte Gruppe von Repositorys oder Zweigen innerhalb Ihrer GitHub Organisation zu beschränken. Informationen zur Konfiguration, um dem OIDC als föderierte Identität AWS zu vertrauen GitHub, finden Sie unter [GitHub Dokumente — Konfiguration von OpenID Connect in](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services) Amazon Web Services. 

Wenn Sie GitHub Umgebungen in Aktionsworkflows oder in OIDC-Richtlinien verwenden, empfehlen wir dringend, der Umgebung Schutzregeln hinzuzufügen, um zusätzliche Sicherheit zu gewährleisten. Verwenden Sie Bereitstellungsverzweigungen und -Tags, um einzuschränken, welche Verzweigungen und Tags in der Umgebung bereitgestellt werden können. Weitere Informationen zur Konfiguration von Umgebungen mit Schutzregeln finden Sie unter [Deployment Branches and Tags](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-branches-and-tags) im Artikel GitHub *Umgebungen für die Bereitstellung verwenden*.

Wenn GitHub der OIDC-IdP der vertrauenswürdige Principal für Ihre Rolle ist, überprüft IAM die Bedingung der Rollenvertrauensrichtlinie, um sicherzustellen, dass der Bedingungsschlüssel vorhanden `token.actions.githubusercontent.com:sub` ist und dass sein Wert nicht nur ein Platzhalterzeichen (\$1 und?) oder null. IAM führt diese Prüfung durch, wenn die Vertrauensrichtlinie erstellt oder aktualisiert wird. Wenn der Bedingungsschlüssel `token.actions.githubusercontent.com:sub` nicht vorhanden ist oder der Schlüsselwert die genannten Wertkriterien nicht erfüllt, schlägt die Anforderung fehl und gibt einen Fehler zurück.

**Wichtig**  
Wenn Sie den Bedingungsschlüssel nicht `token.actions.githubusercontent.com:sub` auf eine bestimmte Organisation oder ein bestimmtes Repository beschränken, können GitHub Aktionen von Organisationen oder Repositorys, auf die Sie keinen Einfluss haben, Rollen übernehmen, die dem GitHub IAM-IdP in Ihrem Konto zugeordnet sind. AWS 

Das folgende Beispiel für eine Vertrauensrichtlinie beschränkt den Zugriff auf die definierte GitHub Organisation, das Repository und die Filiale. Der `token.actions.githubusercontent.com:sub` Wert des Bedingungsschlüssels im folgenden Beispiel ist das Standardformat für den Betreffwert, das von dokumentiert wird GitHub.

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

****  

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

------

Die folgende Beispielbedingung beschränkt den Zugriff auf die definierte GitHub Organisation und das definierte Repository, gewährt jedoch Zugriff auf alle Zweige innerhalb des Repositorys.

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

Die folgende Beispielbedingung beschränkt den Zugriff auf jedes Repository oder jede Filiale innerhalb der definierten GitHub Organisation. Wir empfehlen, dass Sie den Bedingungsschlüssel `token.actions.githubusercontent.com:sub` auf einen bestimmten Wert beschränken, der den Zugriff auf GitHub Aktionen innerhalb Ihrer GitHub Organisation einschränkt.

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

Weitere Informationen zu den OIDC-Verbundschlüsseln, die für Bedingungsprüfungen in Richtlinien verfügbar sind, finden Sie unter [Verfügbare Schlüssel für den AWS OIDC-Verbund](reference_policies_iam-condition-keys.md#condition-keys-wif).

# Rollen für den SAML 2.0-Verbund erstellen (Konsole)
<a name="id_roles_create_for-idp_saml"></a>

 Sie können den SAML 2.0-Verbund verwenden, anstatt IAM-Benutzer in Ihrem zu erstellen. AWS-Konto Mit einem Identitätsanbieter (IdP) können Sie Ihre Benutzeridentitäten außerhalb von verwalten AWS und diesen externen Benutzeridentitäten Berechtigungen für den Zugriff auf AWS Ressourcen in Ihrem Konto erteilen. Weitere Informationen zu Verbund- und Identitätsanbietern finden Sie unter [Identitätsanbieter und Verbund zu AWS](id_roles_providers.md).

**Anmerkung**  
Um die Verbundstabilität zu verbessern, empfehlen wir, dass Sie Ihren IdP und Ihren AWS -Verbund so konfigurieren, dass mehrere SAML-Anmeldeendpunkte unterstützt werden. Einzelheiten finden Sie im AWS Sicherheitsblogartikel [How to use regional SAML](https://aws.amazon.com/blogs//security/how-to-use-regional-saml-endpoints-for-failover) endpoints for Failover.

## Voraussetzungen für das Erstellen einer Rolle für SAML
<a name="idp_saml_Prerequisites"></a>

Bevor Sie eine Rolle für den SAML-2.0-Verbund erstellen können, müssen Sie zunächst folgende Schritte ausführen.<a name="saml-prereqs"></a>

**So erstellen Sie eine Rolle für den SAML 2.0-Verbund**

1. <a name="idpsamlstep1"></a>Bevor Sie eine Rolle für den SAML-basierten Verbund erstellen, müssen Sie einen SAML-Anbieter in IAM erstellen. Weitere Informationen finden Sie unter [Erstellen eines SAML-Identitätsanbieters in IAM](id_roles_providers_create_saml.md).

1. Bereiten Sie die Richtlinien für die Rolle vor, die von den über SAML 2.0 authentifizierten Benutzern übernommen werden sollen. Wie bei jeder Rolle enthält eine Rolle für den SAML-Verbund zwei Richtlinien. Eine davon ist die Vertrauensrichtlinie, die angibt, wer die Rolle übernehmen kann. Die andere ist die IAM-Berechtigungsrichtlinie, die festlegt, auf welche AWS Aktionen und Ressourcen dem SAML-Verbundprinzipal der Zugriff gewährt oder verweigert wird.

   Wenn Sie die Vertrauensrichtlinie für Ihre Rolle erstellen, müssen Sie drei Werte verwenden, um sicherzustellen, dass nur Ihre Anwendung die Rolle übernehmen kann:
   + Verwenden Sie für das Element `Action` die Aktion `sts:AssumeRoleWithSAML`.
   + Verwenden Sie für das Element `Principal` die Zeichenfolge `{"Federated":ARNofIdentityProvider}`. Ersetzen Sie `ARNofIdentityProvider` mit dem ARN des [SAML-Identitätsanbieters](id_roles_providers_saml.md), den Sie in [Step 1](#idpsamlstep1) erstellt haben.
   + Verwenden Sie für das `Condition`-Element eine `StringEquals`-Bedingung, um zu prüfen, ob das `saml:aud`-Attribut aus der SAML-Antwort mit der URL übereinstimmt, die Ihr Browser bei der Anmeldung an der Konsole anzeigt. Diese Anmelde-Endpunkt-URL ist das SAML-Empfängerattribut Ihres Identitätsanbieters. Sie können die Anmeldung URLs innerhalb bestimmter Regionen einbeziehen. AWS empfiehlt, regionale Endpunkte anstelle des globalen Endpunkts zu verwenden, um die Ausfallsicherheit des Verbunds zu verbessern. Eine Liste möglicher *region-code* Werte finden Sie in der Spalte **Region** unter [AWS Anmeldeendpunkte](https://docs.aws.amazon.com/general/latest/gr/signin-service.html).

     Wenn die SAML-Verschlüsselung erforderlich ist, muss die Anmelde-URL die eindeutige Bezeichnung enthalten, die AWS Ihrem SAML-Anbieter zuweist. Sie können die eindeutige ID anzeigen, indem Sie den Identitätsanbieter in der IAM-Konsole auswählen, der die Detailseite anzeigen soll.

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

   Das folgende Beispiel ist auf eine Vertrauensrichtlinie für einen verbundenen SAML-Benutzer ausgelegt:

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

****  

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

------

   Ersetzen Sie den Haupt-ARN durch den tatsächlichen ARN für den SAML-Anbieter, den Sie in IAM erstellt haben. Er enthält Ihre eigene Konto-ID und den Namen des Anbieters. 

## Erstellen einer Rolle für SAML
<a name="idp_saml_Create"></a>

Nachdem Sie die erforderlichen Schritte durchgeführt haben, können Sie die Rolle für den SAML-basierten Verbund anlegen. 

**So erstellen Sie eine Rolle für den SAML-basierten Verbund**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Klicken Sie im Navigationsbereich der IAM-Konsole auf **Roles (Rollen)** und wählen Sie dann **Create role (Rolle erstellen)**.

1. Wählen Sie den Rollentyp **SAML 2.0-Verbund**.

1. Wählen Sie für **Select a SAML provider** (Einen SAML-Anbieter auswählen) den Anbieter für die Rolle. 

1. Wählen Sie die Zugriffsebenen-Methode SAML 2.0. 
   + Wählen Sie **Nur programmatischen Zugriff zulassen** aus, um eine Rolle zu erstellen, die programmgesteuert über die API oder übernommen werden kann. AWS AWS CLI
   + Wählen Sie **Programmatischen AWS-Managementkonsole Zugriff zulassen aus, um eine Rolle zu erstellen, die programmgesteuert und** von der aus übernommen werden kann. AWS-Managementkonsole

   Die erstellten Rollen ähneln einander, aber die Rolle, die auch über die Konsole übernommen werden kann, enthält eine Vertrauensrichtlinie mit einer bestimmten Bedingung. Diese Bedingung stellt ausdrücklich sicher, dass die SAML-Zielgruppe (`SAML:aud`-Attribut) auf den AWS -Anmeldeendpunkt für den SAML-Anbieter verweist.

1. Das Verfahren zur Definition von Attributen ist je nach Zugriffstyp unterschiedlich.
   + Wenn Sie eine Rolle für den programmgesteuerten Zugriff erstellen, wählen Sie ein Attribut aus der Liste **Attribute**. Geben Sie dann im Feld **Value** (Wert) einen Wert ein, der in die Rolle aufgenommen werden soll. Dadurch wird der Rollenzugriff auf die Benutzer des Identitätsanbieters beschränkt, deren SAML-Authentifizierungsantwort (Zusicherung) das angegebene Attribut enthält. Sie müssen mindestens ein Attribut angeben, um sicherzustellen, dass Ihre Rolle auf eine Benutzeruntergruppe in Ihrer Organisation beschränkt ist. 
   + Wenn Sie eine Rolle für Programmatic und AWS-Managementkonsole Access erstellen, definiert der Abschnitt **Anmelde-Endpunkte** die URL, die Ihr Browser bei der Anmeldung an der Konsole anzeigt. Dieser Endpunkt ist das SAML-Empfängerattribut Ihres Identitätsanbieters, das dem [`saml:aud`](reference_policies_iam-condition-keys.md#condition-keys-saml)-Kontextschlüssel zugeordnet ist. Weitere Informationen finden Sie unter [Konfigurieren von SAML-Assertionen für die Authentifizierungsreaktion](id_roles_providers_create_saml_assertions.md).

     1. Wählen Sie **Regionale Endpunkte** oder **Nicht-regionale Endpunkte**. Wir empfehlen, mehrere regionale SAML-Anmelde-Endpunkte zu verwenden, um die Ausfallsicherheit des Verbunds zu verbessern.

     1. Wählen Sie **unter Regionen** die Regionen aus, die Ihr SAML-Anbieter für die Anmeldung unterstützt. AWS 

     1.  Damit die **Anmeldung URLs eindeutige Kennungen enthält**, wählen Sie aus, ob die Anmeldeendpunkte die eindeutigen Kennungen enthalten, die Ihrem SAML-Identitätsanbieter zugewiesen wurden AWS . Diese Option ist für verschlüsselte SAML-Assertionen erforderlich. Weitere Informationen finden Sie unter [SAML 2.0-Föderation](id_roles_providers_saml.md).

1. Um der Vertrauensrichtlinie weitere attributbezogene Bedingungen hinzuzufügen, wählen Sie **Bedingung (optional)**, wählen Sie die zusätzliche Bedingung aus und geben Sie einen Wert an. 
**Anmerkung**  
In der Liste sind die am häufigsten verwendeten SAML-Attribute aufgeführt. IAM unterstützt weitere Attribute, die Sie zum Erstellen von Bedingungen verwenden können. Eine Liste der unterstützten Attribute finden Sie unter [Verfügbare Schlüssel für SAML-Verbund](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-saml). Wenn Sie eine nicht in der Liste enthaltene Bedingung für ein unterstütztes SAML-Attribut benötigen, können Sie diese Bedingung manuell hinzufügen. Bearbeiten Sie dazu die Vertrauensrichtlinie, nachdem Sie die Rolle erstellt haben.

1.  Überprüfen Sie Ihre SAML-2.0-Vertrauensinformationen und wählen Sie dann **Next** (Weiter). 

1. IAM enthält eine Liste der verwalteten und AWS kundenverwalteten Richtlinien in Ihrem Konto. Wählen Sie die Richtlinie aus, die für die Berechtigungsrichtlinie verwendet werden soll, oder wählen Sie **Create policy** (Richtlinie erstellen), um eine neue Registerkarte im Browser zu öffnen und eine neue Richtlinie von Grund auf zu erstellen. Weitere Informationen finden Sie unter [Erstellen von IAM-Richtlinien](access_policies_create-console.md#access_policies_create-start). Nachdem Sie die Richtlinie erstellt haben, schließen Sie die Registerkarte und kehren zur ursprünglichen Registerkarte zurück. Aktivieren Sie das Kontrollkästchen neben den Berechtigungsrichtlinien, über die SAML-Verbundbenutzer verfügen sollen. Wenn Sie es vorziehen, zu diesem Zeitpunkt keine Richtlinien auszuwählen, können Sie sie der Rolle später hinzufügen. Standardmäßig hat eine Rolle keine Berechtigungen.

1. (Optional) Legen Sie eine [Berechtigungsgrenze](access_policies_boundaries.md) fest. Dies ist ein erweitertes Feature.

   Öffnen Sie den Abschnitt **Permissions boundary** (Berechtigungsgrenze) und wählen Sie **Use a permissions boundary to control the maximum role permissions** (Eine Berechtigungsgrenze verwenden, um die maximalen Rollen-Berechtigungen zu steuern). Wählen Sie die Richtlinie aus, die für eine Berechtigungsgrenze verwendet werden soll.

1. Wählen Sie **Weiter** aus.

1. Wählen Sie **Weiter: Prüfen** aus.

1. Geben Sie für **Rollenname** einen Rollennamen ein. Rollennamen müssen innerhalb Ihres AWS-Konto Unternehmens eindeutig sein. Sie werden nicht nach Groß- und Kleinschreibung unterschieden. z. B. können Sie keine Rollen erstellen, die **PRODROLE** bzw. **prodrole** heißen. Da andere AWS Ressourcen möglicherweise auf die Rolle verweisen, können Sie den Namen der Rolle nicht bearbeiten, nachdem sie erstellt wurde. 

1. (Optional) Geben Sie im Feld **Description** (Beschreibung) eine Beschreibung für die neue Rolle ein.

1. Wählen Sie in den Abschnitten **Step 1: Select trusted entities** (Schritt 1: Vertrauenswürdige Entitäten auswählen) oder **Step 2: Add permissions** (Schritt 2: Berechtigungen hinzufügen) die Option **Edit** (Bearbeiten) aus, um die Anwendungsfälle und Berechtigungen für die Rolle zu bearbeiten. 

1. (Optional) Fügen Sie der Rolle Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare anfügen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Tags für AWS Identity and Access Management Ressourcen](id_tags.md).

1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.

Nachdem Sie die Rolle erstellt haben, vervollständigen Sie schließlich die SAML-Vertrauensstellung, indem Sie die Software Ihres Identitätsanbieters mit Informationen zu AWS konfigurieren. Diese Informationen umfassen die Rollen, die Ihre SAML-Verbundbenutzer verwenden sollen. Dies wird als Konfiguration der Vertrauensstellung zwischen Ihrem Identitätsanbieter und AWS bezeichnet. Weitere Informationen finden Sie unter [Konfigurieren Ihres SAML 2.0-IdP mit der Vertrauensstellung der vertrauenden Seite und Hinzufügen von Anträgen](id_roles_providers_create_saml_relying-party.md). 

# Rolle mithilfe benutzerdefinierter Vertrauensrichtlinien erstellen
<a name="id_roles_create_for-custom"></a>

Sie können eine benutzerdefinierte Vertrauensrichtlinie erstellen, um den Zugriff zu delegieren und anderen die Ausführung von Aktionen in Ihrem AWS-Konto zu ermöglichen. Weitere Informationen finden Sie unter [Erstellen von IAM-Richtlinien](access_policies_create-console.md#access_policies_create-start).

Weitere Informationen zur Verwendung von Rollen zum Delegieren von Berechtigungen finden Sie unter [Rollenbegriffe und -konzepte](id_roles.md#id_roles_terms-and-concepts).

## Erstellen einer IAM-Rolle mithilfe benutzerdefinierter Vertrauensrichtlinien (Konsole)
<a name="roles-creatingrole-custom-trust-policy-console"></a>

Sie können die verwenden AWS-Managementkonsole , um eine Rolle zu erstellen, die ein IAM-Benutzer übernehmen kann. Gehen Sie beispielsweise davon aus, dass Ihr Unternehmen über mehrere Systeme verfügt AWS-Konten , um eine Entwicklungsumgebung von einer Produktionsumgebung zu isolieren. Allgemeine Informationen zum Erstellen einer Rolle, mit der Benutzer im Entwicklungskonto auf Ressourcen in der Produktionsumgebung zugreifen können, finden Sie unter [Beispielszenario mit getrennten Entwicklungs- und Produktionskonten](id_roles_common-scenarios_aws-accounts.md#id_roles_common-scenarios_aws-accounts-example).

**Erstellen einer Rolle mithilfe einer benutzerdefinierten Vertrauensrichtlinie (Konsole)**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Klicken Sie im Navigationsbereich der Konsole auf **Roles (Rollen)** und wählen Sie dann **Create role (Rolle erstellen)**.

1. Wählen Sie den Rollentyp **Custom trust policy** (Benutzerdefinierte Vertrauensrichtlinie).

1. Geben Sie im Abschnitt **Custom trust policy** (Benutzerdefinierte Vertrauensrichtlinie) die benutzerdefinierte Vertrauensrichtlinie für die Rolle ein, oder fügen Sie sie ein. Weitere Informationen finden Sie unter [Erstellen von IAM-Richtlinien](access_policies_create-console.md#access_policies_create-start).

1. Beheben Sie alle Sicherheitswarnungen, Fehler oder allgemeinen Warnungen, die während der [Richtlinien-Validierung](access_policies_policy-validator.md) erzeugt wurden, und wählen Sie dann **Next** (Weiter).

1. (Optional) Legen Sie eine [Berechtigungsgrenze](access_policies_boundaries.md) fest. Dies ist ein erweitertes Feature, das für Servicerollen verfügbar ist, aber nicht für servicegebundene Rollen.

   Öffnen Sie den Abschnitt **Permissions boundary** (Berechtigungsgrenze) und wählen Sie **Use a permissions boundary to control the maximum role permissions** (Eine Berechtigungsgrenze verwenden, um die maximalen Rollenberechtigungen zu steuern). IAM enthält eine Liste der AWS verwalteten und kundenverwalteten Richtlinien in Ihrem Konto. Wählen Sie die Richtlinie aus, die für eine Berechtigungsgrenze verwendet werden soll.

1. Wählen Sie **Weiter** aus.

1. Für **Role name (Rollenname)** werden die Anpassungsmöglichkeiten für den Rollennamen durch den Service festgelegt. Wenn der Service den Namen der Rolle definiert, kann diese Option nicht bearbeitet werden. In anderen Fällen kann der Service ein Präfix für die Rolle festlegen und Ihnen das Eingeben eines optionalen Suffixes erlauben. Beim einigen Services können Sie den gesamten Namen Ihrer Rolle angeben.

   Geben Sie, wenn möglich, einen Rollennamen oder ein Rollennamen-Suffix ein. Rollennamen müssen innerhalb Ihres AWS-Konto Unternehmens eindeutig sein. Sie werden nicht nach Groß- und Kleinschreibung unterschieden. z. B. können Sie keine Rollen erstellen, die **PRODROLE** bzw. **prodrole** heißen. Da andere AWS Ressourcen möglicherweise auf die Rolle verweisen, können Sie den Namen der Rolle nicht bearbeiten, nachdem sie erstellt wurde.

1. (Optional) Geben Sie unter **Role description** (Rollenbeschreibung) eine Beschreibung für die neue Rolle ein.

1. (Optional) Wählen Sie **Bearbeiten** im Abschnitt **Schritt 1: Vertrauenswürdige Entitäten auswählen** oder **Schritt 2: Berechtigungen hinzufügen**, um die benutzerdefinierte Richtlinie und die Berechtigungen für die Rolle zu bearbeiten. 

1. (Optional) Fügen Sie der Rolle Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare anfügen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Tags für AWS Identity and Access Management Ressourcen](id_tags.md).

1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.

# Beispiele für Richtlinien zum Delegieren des Zugriffs
<a name="id_roles_create_policy-examples"></a>

Die folgenden Beispiele zeigen, wie Sie einen AWS-Konto Zugriff auf die Ressourcen in einem anderen zulassen oder gewähren können AWS-Konto. Informationen zum Erstellen einer IAM-Richtlinie mithilfe dieser Beispiel-JSON-Richtliniendokumente finden Sie unter [Erstellen von Richtlinien mit dem JSON-Editor](access_policies_create-console.md#access_policies_create-json-editor).

**Topics**
+ [Verwenden Sie Rollen, um den Zugriff auf die Ressourcen anderer AWS-Konto Ressourcen zu delegieren](#example-delegate-xaccount-rolesapi)
+ [Verwenden einer Richtlinie zum Delegieren des Zugriffs auf Services](#id_roles_create_policy-examples-access-to-services)
+ [Verwendung einer ressourcenbasierten Richtlinie zur Delegation des Zugriffs auf einen Amazon S3-Bucket in einem anderen Konto](#example-delegate-xaccount-S3)
+ [Verwendung einer ressourcenbasierten Richtlinie zur Delegation des Zugriffs auf eine Amazon SQS-Warteschlange in einem anderen Konto](#example-delegate-xaccount-SQS)
+ [Delegieren des Zugriffs ist nicht möglich, wenn dem Konto der Zugriff verweigert wird](#example-delegate-xaccount-SQS-denied)

## Verwenden Sie Rollen, um den Zugriff auf die Ressourcen anderer AWS-Konto Ressourcen zu delegieren
<a name="example-delegate-xaccount-rolesapi"></a>

 Ein Tutorial, das zeigt, wie Sie mithilfe von IAM-Rollen Benutzern in einem Konto Zugriff auf AWS Ressourcen gewähren, die sich in einem anderen Konto befinden, finden Sie unter. [IAM-Tutorial: Delegieren Sie den Zugriff über AWS Konten hinweg mithilfe von IAM-Rollen](tutorial_cross-account-with-roles.md) 

**Wichtig**  
Sie können den ARN für eine bestimmte Rolle oder einen bestimmten Benutzer in das `Principal`-Element einer rollenbasierten Vertrauensrichtlinie einschließen. Wenn Sie die Richtlinie speichern, AWS wandelt sie den ARN in eine eindeutige Prinzipal-ID um. Auf diese Weise wird das Risiko reduziert, dass jemand seine Berechtigungen durch Entfernen und Neuerstellen der Rolle oder des Benutzers erweitert. Normalerweise wird diese ID nicht in der Konsole angezeigt, da bei der Anzeige der Vertrauensrichtlinie auch eine Rückumwandlung zum ARN erfolgt. Wenn Sie jedoch die Rolle oder den Benutzer löschen, wird die Beziehung aufgehoben. Die Richtlinie wird nicht mehr angewendet, selbst wenn Sie den Benutzer oder die Rolle neu erstellen, da die Auftraggeber-ID der neuen Rolle nicht mit der in der Vertrauensrichtlinie gespeicherten ID übereinstimmt. In diesem Fall wird die Prinzipal-ID in der Konsole angezeigt, da sie nicht mehr einem ARN zugeordnet werden AWS kann. Das Ergebnis: Wenn Sie einen Benutzer oder eine Rolle löschen und neu erstellen, auf die beide im `Principal`-Element einer Vertrauensrichtlinie verwiesen wird, müssen Sie die Rolle bearbeiten, um den ARN zu ersetzen. Beim Speichern der Richtlinie wird dieser ARN in die neue Auftraggeber-ID umgewandelt.

## Verwenden einer Richtlinie zum Delegieren des Zugriffs auf Services
<a name="id_roles_create_policy-examples-access-to-services"></a>

Das folgende Beispiel zeigt eine Richtlinie, die einer Rolle angefügt werden kann. Die Richtlinie ermöglicht es zwei Diensten, Amazon EMR und AWS Data Pipeline, die Rolle zu übernehmen. Die Services können dann sämtliche Aufgaben ausführen, zu denen die Rolle infolge der zugewiesenen Berechtigungsrichtlinie berechtigt ist (nicht dargestellt). Geben Sie zur Angabe von mehreren Dienstauftraggeber nicht zwei `Service`-Elemente an. Sie können nur ein Element angeben. Verwenden Sie stattdessen ein Array mit mehreren Dienstauftraggeber als Wert eines einzelnen `Service`-Elements.

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

****  

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

------

## Verwendung einer ressourcenbasierten Richtlinie zur Delegation des Zugriffs auf einen Amazon S3-Bucket in einem anderen Konto
<a name="example-delegate-xaccount-S3"></a>

In diesem Beispiel verwendet Konto A eine ressourcenbasierte Richtlinie (eine Amazon S3-[Bucket-Richtlinie](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucketPolicies.html)), um dem Konto B vollen Zugriff auf den S3-Bucket in Konto A zu gewähren. Konto B erstellt dann eine IAM-Benutzerrichtlinie, um diesen Zugriff auf den Bucket in Konto A auf einen Benutzer im Konto B zu delegieren. 

Die S3-Bucket-Richtlinie in Konto A sieht beispielsweise folgendermaßen. In diesem Beispiel heißt der S3-Bucket von Konto A *amzn-s3-demo-bucket* und die Kontonummer von Konto B lautet 111122223333. In der Richtlinie werden keine einzelnen Benutzer oder Gruppen in Konto B angegeben, nur das Konto selbst.

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

****  

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

------

Alternativ kann Konto A Amazon S3 [Access Control Lists (ACLs)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3_ACLs_UsingACLs.html) verwenden, um Konto B Zugriff auf einen S3-Bucket oder ein einzelnes Objekt innerhalb eines Buckets zu gewähren. In diesem Fall besteht der einzige Unterschied darin, wie Konto A dem Konto B die Zugriffsberechtigung erteilt. Konto B verwendet unverändert eine Richtlinie, um den Zugriff an eine IAM-Gruppe in Konto B zu delegieren, wie im nächsten Teil des Beispiels beschrieben. Weitere Informationen zur Zugriffkontrolle auf S3-Buckets und Objekte finden Sie unter [Access Control](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingAuthAccess.html) im *Benutzerhandbuch für Amazon Simple Storage Service*. 

Das Administrator von Konto B erstellt möglicherweise die folgende Beispielrichtlinie. Die Richtlinie gewährt Lesezugriff auf eine Gruppe oder einen Benutzer in Konto B. Die vorhergehende Richtlinie gewährt Zugriff auf Konto B. Einzelne Gruppen und Benutzer in Konto B haben jedoch erst Zugriff auf die Ressource, nachdem eine Gruppen- oder Benutzerrichtlinie explizit Berechtigungen für die Ressource gewährt hat. Die Berechtigungen in dieser Richtlinie können nur eine Untermenge der Berechtigungen in der vorhergehenden kontoübergreifenden Richtlinie sein. Konto B kann seinen Gruppen und Benutzern nicht mehr Berechtigungen erteilen, als jene, die das Konto A dem Konto B in der ersten Richtlinie erteilt hat. In dieser Richtlinie werden im Element `Action` explizit nur die Aktionen `List` zugelassen und das Element `Resource` in dieser Richtlinie stimmt mit der `Resource` in der von Konto A eingesetzten Bucketrichtlinie überein.

Zur Implementierung dieser Richtlinie verwendet Konto B IAM, um sie dem entsprechenden Benutzer (oder der entsprechenden Gruppe) in Konto B anzufügen. 

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

****  

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

------

## Verwendung einer ressourcenbasierten Richtlinie zur Delegation des Zugriffs auf eine Amazon SQS-Warteschlange in einem anderen Konto
<a name="example-delegate-xaccount-SQS"></a>

Im folgenden Beispiel verfügt Konto A über eine Amazon SQS-Warteschlange, die eine der Warteschlange angefügte ressourcenbasierte Richtlinie verwendet, um dem Konto B Zugriff auf die Warteschlange zu gewähren. Konto B verwendet dann eine IAM-Gruppenrichtlinie zum Delegieren des Zugriffs an eine Gruppe in Konto B. 

Die folgende Beispielrichtlinie für eine Warteschlange erteilt Konto B die Berechtigung, `SendMessage`- und `ReceiveMessage`-Aktionen in der Warteschlange des Kontos A mit dem Namen *queue1* ausschließlich am 30. November 2014 zwischen 12:00 und 15:00 Uhr auszuführen. Die Kontonummer des Kontos B lautet 1111-2222-3333. Konto A verwendet Amazon SQS zum Implementieren dieser Richtlinie. 

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

****  

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

------

Die Richtlinie für das Delegieren des Zugriffs auf eine Gruppe in Konto B könnte folgendermaßen aussehen. Konto B verwendet IAM, um die Richtlinie einer Gruppe (oder einem Benutzer) anzufügen. 

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

****  

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

------

Im vorangegangenen Beispiel der IAM-Benutzerrichtlinie verwendet Konto B einen Platzhalter, um seinem Benutzer Zugriff auf alle Amazon SQS-Aktionen in der Warteschlange von Konto A zu gewähren. Konto B kann den Zugriff jedoch nur in dem Umfang delegieren, in dem Konto B Zugriff gewährt wurde. Die Gruppe in Konto B, die über die zweite Richtlinie verfügt, kann nur zwischen 12:00 Uhr und 15:00 Uhr am 30. November 2014 auf die Warteschlange zugreifen. Der Benutzer kann nur die Aktionen `SendMessage` und `ReceiveMessage` ausführen, wie in der Amazon SQS-Warteschlangenrichtlinie von Konto A definiert. 

## Delegieren des Zugriffs ist nicht möglich, wenn dem Konto der Zugriff verweigert wird
<a name="example-delegate-xaccount-SQS-denied"></a>

An AWS-Konto kann den Zugriff auf die Ressourcen eines anderen Kontos nicht delegieren, wenn das andere Konto den Zugriff auf das übergeordnete Konto des Benutzers ausdrücklich verweigert hat. Die Zugriffsverweigerung wird den Benutzern in diesem Konto propagiert, unabhängig davon, ob diese Benutzer über Richtlinien verfügen, die ihnen Zugriffsberechtigungen erteilen.

In Konto A ist beispielsweise eine Bucketrichtlinie für den S3-Bucket in Konto A definiert, die dem Konto B den Zugriff auf den Bucket in Konto A explizit verweigert. Andererseits enthält Konto B eine IAM-Benutzerrichtlinie, die einem Benutzer in Konto B den Zugriff auf den Bucket in Konto A gewährt. Die explizite Zugriffsverweigerung auf den S3-Bucket in Konto A wird den Benutzern in Konto B propagiert. Sie überschreibt die IAM-Benutzerrichtlinie, die dem Benutzer in Konto B die Zugriffsberechtigung erteilt (weitere Informationen, wie Berechtigungen ausgewertet werden, finden Sie unter ). [Auswertungslogik für Richtlinien](reference_policies_evaluation-logic.md).) 

Die Richtlinie des Buckets in Konto A sieht beispielsweise folgendermaßen. In diesem Beispiel heißt der S3-Bucket von Konto A *amzn-s3-demo-bucket* und die Kontonummer von Konto B lautet 1111-2222-3333. Konto A verwendet Amazon S3; zum Implementieren dieser Richtlinie. 

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

****  

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

------

Diese explizite Zugriffsverweigerung überschreibt alle Richtlinien in Konto B, die zum Zugriff auf den S3-Bucket in Konto A berechtigen. 

# IAM-Rollen-Verwaltung
<a name="id_roles_manage"></a>

Bevor ein Benutzer, Anwendungen oder Services eine von Ihnen erstellte Rolle verwenden können, müssen Sie Berechtigungen zum Wechseln zu dieser Rolle erteilen. Sie können jede Richtlinie verwenden, die Gruppen oder Benutzern angefügt ist, um die erforderlichen Berechtigungen zu gewähren. In diesem Abschnitt wird beschrieben, wie Sie Benutzern die Berechtigung zur Verwendung einer Rolle gewähren. Außerdem wird erklärt, wie der Benutzer über die Tools für Windows AWS-Managementkonsole PowerShell, die AWS Command Line Interface (AWS CLI) und die [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API zu einer Rolle wechseln kann.

**Wichtig**  
Wenn Sie die Rolle programmgesteuert anstatt in der IAM-Konsole erstellen, haben Sie die Möglichkeit, einen `Path` mit bis zu 512 Zeichen und einen `RoleName` mit bis zu 64 Zeichen hinzuzufügen. Wenn Sie jedoch beabsichtigen, eine Rolle mit der Funktion „**Rolle wechseln**“ in der zu verwenden AWS-Managementkonsole, dann die Kombination `Path` und `RoleName` darf 64 Zeichen nicht überschreiten.

**Topics**
+ [Anzeigen des Rollenzugriffs](#roles-modify_prerequisites)
+ [Generieren einer Richtlinie basierend auf Zugriffsinformationen](#roles-modify_gen-policy)
+ [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md)
+ [Erteilen Sie einem Benutzer die Erlaubnis, eine Rolle an einen AWS Dienst zu übergeben](id_roles_use_passrole.md)
+ [Temporäre Sicherheitsanmeldeinformationen der IAM-Rolle widerrufen](id_roles_use_revoke-sessions.md)
+ [Serviceverknüpfte Rolle aktualisieren](id_roles_update-service-linked-role.md)
+ [Rollenvertrauensrichtlinie aktualisieren](id_roles_update-role-trust-policy.md)
+ [Berechtigungen für eine Rolle aktualisieren](id_roles_update-role-permissions.md)
+ [Aktualisieren der Einstellungen für eine Rolle](id_roles_update-role-settings.md)
+ [Rollen oder Instance-Profile löschen](id_roles_manage_delete.md)

## Anzeigen des Rollenzugriffs
<a name="roles-modify_prerequisites"></a>

Bevor Sie die Berechtigungen für eine Rolle ändern, sollten Sie ihre kürzliche Service-Level-Aktivität überprüfen. Das ist wichtig, da Sie keinem Auftraggeber (Person oder Anwendung) einen noch verwendeten Zugriff entziehen möchten. Weitere Informationen zum Anzeigen der Informationen zum letzten Zugriff finden Sie unter [Verfeinern Sie die Berechtigungen für AWS die Verwendung der zuletzt abgerufenen Informationen](access_policies_last-accessed.md).

## Generieren einer Richtlinie basierend auf Zugriffsinformationen
<a name="roles-modify_gen-policy"></a>

Manchmal können Sie einer IAM-Entität (Benutzer oder Rolle) Berechtigungen erteilen, die über das hinausgehen, was diese benötigen. Um Ihnen beim Verfeinern der Berechtigungen zu helfen, können Sie eine IAM-Richtlinie generieren, die auf der Zugriffsaktivität für eine Entity basiert. IAM Access Analyzer überprüft Ihre AWS CloudTrail Protokolle und generiert eine Richtlinienvorlage, die die Berechtigungen enthält, die von der Entität in dem von Ihnen angegebenen Zeitraum verwendet wurden. Sie können die Vorlage verwenden, um eine verwaltete Richtlinie mit definierten Berechtigungen zu erstellen und sie dann an die IAM-Rolle anzuhängen. Auf diese Weise gewähren Sie nur die Berechtigungen, die der Benutzer oder die Rolle benötigt, um mit AWS Ressourcen für Ihren speziellen Anwendungsfall zu interagieren. Weitere Informationen finden Sie unter [Richtliniengenerierung für IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-generation.html).

# Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel
<a name="id_roles_use_permissions-to-switch"></a>

Wenn ein Administrator eine Rolle [für kontenübergreifenden Zugriff erstellt](id_roles_create_for-user.md), richtet er eine Vertrauensstellung zwischen dem Konto, zu dem die Rolle gehört, sowie den Ressourcen (vertrauendes Konto) und dem Konto ein, das die Benutzer enthält (vertrauenswürdiges Konto). Zu diesem Zweck gibt der Administrator des vertrauenswürdigen Kontos die Nummer des vertrauenswürdigen Kontos als `Principal` in der Vertrauensrichtlinie der Rolle an. Dadurch kann jeder Benutzer im vertrauenswürdigen Konto *potenziell* die Rolle übernehmen. Zum Abschließen der Konfiguration muss der Administrator des vertrauenswürdigen Kontos bestimmten Gruppen oder Benutzern in diesem Konto die Berechtigung zum Wechseln zu der Rolle erteilen.

**So erteilen Sie die Berechtigung zum Wechseln einer Rolle**

1. Erstellen Sie als Administrator des vertrauenswürdigen Kontos eine neue Richtlinie für den Benutzer, oder bearbeiten Sie eine bestehende Richtlinie, um die erforderlichen Elemente hinzuzufügen. Details hierzu finden Sie unter [Erstellen oder Bearbeiten der Richtlinie](#roles-usingrole-createpolicy).

1. Wählen Sie dann, wie Sie die Rolleninformationen freigeben möchten: 
   + **Link zur Rolle:** Sie können den Benutzern einen Link zusenden, mit dem sie zur Seite **Switch Role (Rolle wechseln)** gelangen, auf der sämtliche Angaben bereits ausgefüllt sind. 
   + **Konto-ID oder Alias:** Geben Sie jedem Benutzer den Rollennamen sowie die Konto-ID-Nummer oder den Konto-Alias. Der Benutzer öffnet dann die Seite **Switch Role (Rolle wechseln)** und gibt die Details manuell ein. 

   Details hierzu finden Sie unter [Bereitstellen von Informationen an den Benutzer](#roles-usingrole-giveuser).

Beachten Sie, dass Sie die Rollen nur wechseln können, wenn Sie sich als IAM-Benutzer, als SAML-Verbundrolle oder mit einer Web-Identitäts-Verbundrolle anmelden. Sie können keine Rollen wechseln, wenn Sie als Root-Benutzer des AWS-Kontos angemeldet sind.

**Wichtig**  
Sie können die Rollen in nicht AWS-Managementkonsole zu einer Rolle wechseln, für die ein [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id)Wert erforderlich ist. Sie können nur zu einer solchen Rolle wechseln, indem Sie die [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)-API aufrufen, die den `ExternalId`-Parameter unterstützt.

**Hinweise**  
In diesem Thema werden die Richtlinien für einen *Benutzer* erörtert, da Sie letztendlich einem Benutzer die Berechtigungen zum Erledigen einer Aufgabe erteilen. Wir raten Ihnen jedoch davon ab, einem einzelnen Benutzer direkt Berechtigungen zu erteilen. Wenn ein Benutzer eine Rolle annimmt, werden ihm die mit dieser Rolle verknüpften Berechtigungen zugewiesen.
Wenn Sie die Rollen in der wechseln AWS-Managementkonsole, verwendet die Konsole immer Ihre ursprünglichen Anmeldeinformationen, um den Switch zu autorisieren. Dies gilt unabhängig davon, ob Sie sich als IAM-Benutzer, als SAML-verbundene Rolle oder mit einer Web-Identität verbundenen Rolle anmelden. Wenn Sie beispielsweise zu RoleA wechseln, verwendet IAM; die Anmeldeinformationen Ihres ursprünglichen Benutzers oder Ihrer verbundenen Rolle, um festzustellen, ob Sie RoleA annehmen dürfen. Wenn Sie dann versuchen, zu RolleB zu wechseln, *während Sie RolleA verwenden*, werden Ihre **ursprünglichen** Benutzer- oder Verbundrollen-Anmeldeinformationen verwendet, um Ihren Versuch zu autorisieren. Die Anmeldeinformationen für RoleA werden für diese Aktion nicht verwendet.

**Topics**
+ [Erstellen oder Bearbeiten der Richtlinie](#roles-usingrole-createpolicy)
+ [Bereitstellen von Informationen an den Benutzer](#roles-usingrole-giveuser)

## Erstellen oder Bearbeiten der Richtlinie
<a name="roles-usingrole-createpolicy"></a>

Eine Richtlinie, die dem Benutzer die Berechtigung zum Übernehmen einer Rolle gewährt, muss eine Anweisung enthalten, die für folgende Komponenten `Allow` gewährt: 
+ `sts:AssumeRole`-Aktion
+ Amazon-Ressourcenname (ARN) der Rolle in einem `Resource`Element

Benutzer, die diese Richtlinie erhalten, dürfen die Rolle der aufgelisteten Ressource wechseln (entweder über eine Gruppenmitgliedschaft oder direkt angehängt).

**Anmerkung**  
Wenn `Resource` auf `*` gesetzt ist, kann der Benutzer jede Rolle in jedem Konto übernehmen, das dem Konto des Benutzers vertraut. (Mit anderen Worten, die Vertrauensrichtlinie der Rolle gibt das Konto des Benutzers als `Principal` an). Als bewährte Methode empfehlen wir, dass Sie das [Prinzip der Mindestberechtigung](http://en.wikipedia.org/wiki/Principle_of_least_privilege) anwenden und den vollständigen ARN nur für die Rollen festlegen, die der Benutzer benötigt.

Das folgende Beispiel zeigt eine Richtlinie, mit der der Benutzer Rollen in nur einem Konto übernehmen kann. Zudem verwendet die Richtlinie einen Platzhalter (\$1), um anzugeben, dass der Benutzer nur zu einer Rolle wechseln kann, wenn der Rollenname mit den Buchstaben `Test` beginnt.

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

****  

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

------

**Anmerkung**  
Die Berechtigungen, die die Rolle dem Benutzer gewährt, werden nicht zu den Berechtigungen addiert, die dem Benutzer bereits gewährt wurden. Wenn ein Benutzer zu einer Rolle wechselt, verzichtet er vorübergehend auf seine ursprünglichen Berechtigungen und erhält die Berechtigungen, die durch die Rolle gewährt werden. Wenn der Benutzer die Rolle beendet, werden die ursprünglichen Benutzerberechtigungen automatisch wiederhergestellt. Angenommen, die Berechtigungen des Benutzers erlauben die Arbeit mit Amazon EC2-Instaces, aber die Berechtigungsrichtlinie der Rolle gewährt diese Berechtigungen nicht. In diesem Fall kann der Benutzer, während er die Rolle verwendet, nicht mit Amazon EC2-Instances in der Konsole arbeiten. Darüber hinaus funktionieren über `AssumeRole` abgerufene temporäre Anmeldeinformationen nicht programmgesteuert mit Amazon EC2-Instances.

## Bereitstellen von Informationen an den Benutzer
<a name="roles-usingrole-giveuser"></a>

Nachdem Sie eine Rolle erstellt und dem Benutzer die Berechtigungen zum Wechseln zu dieser Rolle gewährt haben, müssen Sie dem Benutzer Folgendes bereitstellen:
+ Der Name der Rolle
+ Konto-ID oder Kontoalias mit der Rolle

Sie können den Vorgang für Ihre Benutzer erleichtern, indem Sie ihnen einen Link zusenden, der mit der Konto-ID und dem Rollennamen vorkonfiguriert ist. Sie können den Link zur Rolle sehen, nachdem Sie den Assistenten zum **Erstellen einer Rolle** abgeschlossen haben, indem Sie das Banner **Rolle anzeigen** auswählen oder auf der Seite **Rollenübersicht** für jede kontoübergreifende Rolle klicken.

Sie können auch das folgende Format verwenden, um den Link manuell zu erstellen. Ersetzen Sie die beiden Parameter in der Anforderung durch Ihre Konto-ID bzw. den Alias und den Rollennamen.

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

Wir empfehlen Ihnen, Ihre Benutzer zum Thema [Von einem Benutzer zu einer IAM-Rolle wechseln (Konsole)](id_roles_use_switch-role-console.md) weiterzuleiten, um sie schrittweise durch den Prozess zu führen. Zur Behebung typischer Probleme beim Übernehmen einer Rolle vgl. [Ich kann eine Rolle nicht übernehmen](troubleshoot_roles.md#troubleshoot_roles_cant-assume-role).

**Überlegungen**
+ Wenn Sie die Rolle programmatisch erstellen, können Sie einen Pfad und einen Namen angeben. In diesem Fall müssen Sie Ihren Benutzern den vollständigen Pfad und den Rollennamen zur Eingabe auf der Seite **Switch Role (Rolle wechseln)** der AWS-Managementkonsole bereitstellen. Beispiel: `division_abc/subdivision_efg/role_XYZ`.
+ Wenn Sie die Rolle programmatisch erstellen, können Sie einen `Path` von bis zu 512 Zeichen und einen `RoleName` hinzufügen. Er kann eine Länge von bis zu 64 Zeichen umfassen. Um jedoch eine Rolle mit der Funktion „**Rolle wechseln**“ in der zu verwenden AWS-Managementkonsole, darf die Kombination `Path` 64 Zeichen `RoleName` nicht überschreiten.
+ Aus Sicherheitsgründen können Sie in den [AWS CloudTrail Protokollen nachlesen](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds), wer eine Aktion in ausgeführt hat AWS. Sie können den `sts:SourceIdentity`-Bedingungsschlüssel in der Rollenvertrauensrichtlinie verwenden, damit Benutzer einen Sitzungsnamen angeben müssen, wenn sie eine Rolle übernehmen. Sie können beispielsweise verlangen, dass IAM-Benutzer ihren eigenen Benutzernamen als Sitzungsnamen angeben. Auf diese Weise können Sie feststellen, welcher Benutzer eine bestimmte Aktion in AWS ausgeführt hat. Weitere Informationen finden Sie unter [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity). Sie können auch [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname) verwenden, um von den Benutzern zu verlangen, dass sie einen Sitzungsnamen angeben, wenn sie eine Rolle übernehmen. Auf diese Weise können Sie zwischen Rollensitzungen unterscheiden, wenn eine Rolle von verschiedenen Auftraggeber verwendet wird.

# Erteilen Sie einem Benutzer die Erlaubnis, eine Rolle an einen AWS Dienst zu übergeben
<a name="id_roles_use_passrole"></a>

Um viele AWS Dienste zu konfigurieren, müssen Sie dem Dienst eine IAM-Rolle *übergeben*. Dies erlaubt dem Service, später die Rolle anzunehmen und in Ihrem Auftrag Aktionen durchzuführen. Für die meisten Services müssen Sie die Rolle nur einmal während der Einrichtung an den Service übergeben, und nicht jedes Mal, wenn der Service die Rolle annimmt. Angenommen, es wird eine Anwendung auf einer Amazon EC2-Instance ausgeführt. Diese Anwendung erfordert temporäre Anmeldeinformationen zur Authentifizierung und Berechtigungen für die Autorisierung der Anwendung, damit diese Aktionen in AWS durchführen kann. Wenn Sie die Anwendung einrichten, müssen Sie eine Rolle an Amazon EC2 übergeben, die mit der Instance verwendet wird, die diese Anmeldeinformationen bereitstellt. Sie definieren die Berechtigungen für die Anwendungen, die in dieser Instance ausgeführt werden, indem Sie der Rolle eine IAM-Richtlinie anfügen. Die Anwendung nimmt die Rolle immer an, wenn die Aktionen im Rahmen der Rolle ausgeführt werden.

Um eine Rolle (und ihre Berechtigungen) an einen AWS Dienst zu übergeben, muss ein Benutzer über die erforderlichen Berechtigungen verfügen, um *die Rolle an den Dienst weiterzugeben*. So können Administratoren sicherstellen, dass nur berechtigte Benutzer einen Service mit einer Rolle konfigurieren können, über die Berechtigungen verliehen werden. Damit ein Benutzer eine Rolle an einen AWS Dienst übergeben kann, müssen Sie dem IAM-Benutzer, der Rolle oder der Gruppe des Benutzers die `PassRole` entsprechende Berechtigung erteilen.

**Warnung**  
Sie können die `PassRole` Berechtigung nur verwenden, um eine IAM-Rolle an einen Dienst zu übergeben, der dasselbe AWS Konto verwendet. Um eine Rolle in Konto A an einen Service in Konto B zu übergeben, müssen Sie zunächst eine IAM-Rolle in Konto B erstellen, die die Rolle von Konto A übernehmen kann. Anschließend kann die Rolle in Konto B an den Service übergeben werden. Details hierzu finden Sie unter [Kontoübergreifender Zugriff auf Ressourcen in IAM](access_policies-cross-account-resource-access.md).
Versuchen Sie nicht zu kontrollieren, wer eine Rolle weitergeben kann, indem Sie die Rolle taggen und dann den `ResourceTag`-Bedingungsschlüssel in einer Richtlinie mit der `iam:PassRole`-Aktion verwenden. Dieser Ansatz führt nicht zu zuverlässigen Ergebnissen.

Beim Festlegen der `PassRole`-Berechtigung sollten Sie darauf achten, dass ein Benutzer keine Rolle übergibt, die über mehr Berechtigungen verfügt, als Sie dem Benutzer gewähren möchten. Zum Beispiel darf Alice möglicherweise keine Amazon-S3-Aktionen ausführen. Wenn Alice einem Service eine Rolle übergeben könnte, der Amazon-S3-Aktionen zulässt, könnte der Service bei der Ausführung des Auftrags Amazon-S3-Aktionen im Namen von Alice durchführen.

Wenn Sie eine serviceverknüpfte Rolle angeben, müssen Sie zudem über die Berechtigung verfügen, diese Rolle an den Service übergeben. Einige Services erstellen automatisch eine serviceverknüpfte Rolle in Ihrem Konto, wenn Sie eine Aktion in diesem Service durchführen. Zum Beispiel erstellt Amazon EC2 Auto Scaling die serviceverknüpfte Rolle `AWSServiceRoleForAutoScaling` für Sie, wenn Sie das erste Mal eine Auto-Scaling-Gruppe erstellen. Wenn Sie versuchen, die Berechtigung anzugeben, wenn Sie eine Auto-Scaling-Gruppe erstellen, und Sie haben keine `iam:PassRole`-Berechtigung, erhalten Sie einen Fehler. Wenn Sie die Rolle nicht explizit angeben, ist die `iam:PassRole`-Berechtigung nicht erforderlich, und standardmäßig wird die `AWSServiceRoleForAutoScaling`-Rolle für alle Operationen verwendet, die für diese Gruppe ausgeführt werden. Informationen dazu, welche Services serviceverknüpfte Rollen unterstützen, finden Sie unter [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md). Um zu erfahren, welche Services automatisch eine serviceverknüpfte Rolle erstellen, wenn Sie eine Aktion in diesem Service durchführen, wählen Sie den Link **Yes (Ja)** und zeigen Sie die serviceverknüpfte Rollendokumentation für den Service an.

Ein Benutzer kann einen Rollen-ARN als Parameter in einer API-Operation übergeben, die die Rolle für die Zuweisung von Berechtigungen für den Service verwendet. Der Service überprüft dann, ob der betreffende Benutzer über die Berechtigung `iam:PassRole` verfügt. Damit der Benutzer nur genehmigte Rollen übergeben kann, können Sie die Berechtigung `iam:PassRole` mit dem Element `Resources` der IAM-Richtlinienanweisung filtern. 

Sie können das `Condition` Element in einer JSON-Richtlinie verwenden, um den Wert von Schlüsseln zu testen, die im Anforderungskontext aller AWS Anfragen enthalten sind. Weitere Informationen zur Verwendung von Bedingungsschlüsseln in einer Richtlinie finden Sie unter [IAM-JSON-Richtlinienelemente: Condition](reference_policies_elements_condition.md). Der `iam:PassedToService`-Bedingungsschlüssel kann verwendet werden, um den Auftraggeber des Dienstes anzugeben, an den eine Rolle übergeben werden kann. Weitere Informationen zur Verwendung des `iam:PassedToService` Bedingungsschlüssels in einer Richtlinie finden Sie unter [iam: PassedToService](reference_policies_iam-condition-keys.md#ck_PassedToService).

**Beispiel 1**  
Angenommen, Sie möchten einem Benutzer die Berechtigung verleihen, beim Starten einer Instance beliebige genehmigte Rollen an den Amazon-EC2-Service zu übergeben. Dafür sind drei Elemente nötig:
+ Eine IAM-*Berechtigungsrichtlinie*, die der Rolle zugeordnet ist und über die festgelegt wird, was mit der Rolle getan werden kann. Weisen Sie nur Berechtigungen für Aktionen zu, die für die Rolle erforderlich sind, und nur für die Ressourcen, die von der Rolle für diese Aktionen benötigt werden. Sie können eine AWS verwaltete oder vom Kunden erstellte IAM-Berechtigungsrichtlinie verwenden.

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

****  

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

------
+ Eine *Vertrauensrichtlinie* für die Rolle, die es dem Service ermöglicht, die Rolle anzunehmen. Sie können beispielsweise der Rolle mit der Aktion `UpdateAssumeRolePolicy` die folgende Vertrauensrichtlinie zuweisen. Über diese Vertrauensrichtlinie kann Amazon EC2 die Rolle und deren Berechtigungen verwenden.

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

****  

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

------
+ Eine IAM-*Berechtigungsrichtlinie*, die dem IAM-Benutzer zugeordnet ist und diesem ermöglicht, nur genehmigte Rollen zu übergeben. Sie fügen normalerweise `iam:GetRole` zu `iam:PassRole`, damit der Benutzer die Details weitergeben kann. In diesem Beispiel kann der Benutzer nur Rollen weitergeben, die im angegebenen Konto mit Namen vorhanden sind, die mit `EC2-roles-for-XYZ-` beginnen:

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

****  

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

------

Der Benutzer kann jetzt eine Amazon EC2-Instance mit einer zugewiesenen Rolle starten. Anwendungen auf der Instance können über die Metadaten des Instance-Profils auf temporäre Anmeldeinformationen für die Rolle zugreifen. Die der Rolle zugeordneten Berechtigungsrichtlinien legen fest, welche Aktionen die Instance ausführen kann. 

**Beispiel 2**  
Amazon Relational Database Service (Amazon RDS) unterstützt die Feature namens **„Verbesserte Überwachung“**. Mit dieses Feature kann Amazon RDS eine Datenbank-Instance mithilfe eines Agenten überwachen. Es ermöglicht Amazon RDS auch, Metriken in Amazon Logs zu CloudWatch protokollieren. Um dieses Feature zu aktivieren, müssen Sie eine Servicerolle erstellen, um Amazon RDS die Berechtigung zum Überwachen und Speichern von Metriken in Ihren Protokollen zu gewähren. 

**So erstellen Sie eine IAM-Rolle für Enhanced Monitoring in Amazon RDS**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie **Roles (Rollen)** und anschließend **Create role (Rolle erstellen)**.

1. Wählen Sie den Rollentyp **AWS Service** und dann für **Anwendungsfälle für andere AWS-Services** den **RDS-Dienst** aus. Wählen Sie **RDS – Enhanced Monitoring** (RDS – erweiterte Überwachung) und **Next** (Weiter) aus.

1. Wählen Sie die **RDSEnhancedMonitoringRoleAmazon-Berechtigungsrichtlinie** aus.

1. Wählen Sie **Weiter** aus.

1. Geben Sie unter **Role name** (Rollenname) einen Rollennamen ein, der Ihnen hilft, den Zweck dieser Rolle zu identifizieren. Rollennamen müssen innerhalb Ihres Unternehmens eindeutig sein AWS-Konto. Wenn ein Rollenname in einer Richtlinie oder als Teil eines ARN verwendet wird, muss die Groß-/Kleinschreibung des Rollennamens beachtet werden. Wenn Kunden in der Konsole ein Rollenname angezeigt wird, beispielsweise während des Anmeldevorgangs, wird die Groß-/Kleinschreibung des Rollennamens nicht beachtet. Da verschiedene Entitäten möglicherweise auf die Rolle verweisen, können Sie den Namen der Rolle nach der Erstellung nicht mehr bearbeiten.

1. (Optional) Geben Sie unter **Role description** (Rollenbeschreibung) eine Beschreibung für die neue Rolle ein.

1. (Optional) Fügen Sie dem Benutzer Metadaten hinzu, indem Sie Markierungen als Schlüssel-Wert-Paare anfügen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Tags für AWS Identity and Access Management Ressourcen](id_tags.md).

1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.

Der Rolle wird automatisch eine Vertrauensrichtlinie zugewiesen, die dem Service `monitoring.rds.amazonaws.com` die Berechtigung zum Übernehmen der Rolle gewährt. Nun kann Amazon RDS; alle durch die Richtlinie `AmazonRDSEnhancedMonitoringRole` gewährten Aktionen ausführen.

Der Benutzer, der auf Enhanced Monitoring zugreifen soll, benötigt eine Richtlinie wie die folgende, die eine Anweisung enthält, die es dem Benutzer ermöglicht, die RDS-Rollen aufzulisten und eine Anweisung, die es dem Benutzer ermöglicht, die Rolle zu übergeben. Verwenden Sie Ihre Kontonummer und ersetzen Sie den Rollennamen durch den Namen, den Sie in Schritt 6 eingegeben haben.

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

Sie können diese Anweisung mit Anweisungen in einer anderen Richtlinie kombinieren oder eine eigene Richtlinie dafür erstellen. Um stattdessen festzulegen, dass der Benutzer jede Rolle übergeben kann, die mit `RDS-` beginnt, ersetzen Sie wie folgt den Rollennamen im Ressourcen-ARN durch einen Platzhalter.

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

## `iam:PassRole`Aktionen in AWS CloudTrail Protokollen
<a name="id_roles_use_passrole_logs"></a>

 `PassRole`ist kein API-Aufruf. `PassRole`ist eine Berechtigung, was bedeutet, dass keine CloudTrail Protokolle für IAM `PassRole` generiert werden. Um zu überprüfen, welche Rollen an welche AWS-Services übergeben wurden CloudTrail, müssen Sie das CloudTrail Protokoll überprüfen, das die AWS Ressource, der die Rolle zugewiesen wurde, erstellt oder geändert hat. Beispielsweise wird eine Rolle bei ihrer Erstellung an eine AWS Lambda Funktion übergeben. Das Protokoll für die `CreateFunction`-Aktion zeigt eine Aufzeichnung der Rolle, die an die Funktion übergeben wurde. 

# Temporäre Sicherheitsanmeldeinformationen der IAM-Rolle widerrufen
<a name="id_roles_use_revoke-sessions"></a>

**Warnung**  
Wenn Sie die Schritte auf dieser Seite befolgen, wird allen Benutzern mit aktuellen Sitzungen, die durch Übernahme der Rolle erstellt wurden, der Zugriff auf alle AWS Aktionen und Ressourcen verweigert. Dies kann dazu führen, dass Benutzer nicht gespeicherte Arbeit verlieren.

Wenn Sie Benutzern den Zugriff auf die AWS-Managementkonsole mit einer langen Sitzungsdauer (z. B. 12 Stunden) gestatten, laufen ihre temporären Anmeldeinformationen nicht so schnell ab. Wenn Benutzer versehentlich ihre Anmeldeinformationen nicht autorisierten Dritten preisgeben, haben diese für die Dauer der Sitzung entsprechenden Zugriff. Sie können jedoch sofort alle Berechtigungen für die Anmeldeinformationen der Rolle widerrufen, die vor einem bestimmten Zeitpunkt ausgestellt wurden, wenn dies erforderlich ist. Alle temporären Anmeldeinformationen für diese Rolle, die vor dem angegebenen Zeitpunkt ausgestellt wurden, werden ungültig. Dies zwingt alle Benutzer, sich erneut zu authentifizieren und neue Anmeldeinformationen anfordern.

 

**Anmerkung**  
Die Sitzung für eine *[serviceverknüpfte Rolle](id_roles.md#iam-term-service-linked-role)* können Sie nicht widerrufen.

Wenn Sie mithilfe des in diesem Thema beschriebenen Verfahrens Berechtigungen für eine Rolle entziehen, AWS fügt der Rolle eine neue Inline-Richtlinie hinzu, die alle Berechtigungen für alle Aktionen verweigert. Sie enthält eine Bedingung, die die Einschränkungen nur dann anwendet, wenn der Benutzer die Rolle *vor* dem Zeitpunkt übernommen hat, zu dem Sie die Berechtigungen widerrufen. Wenn der Benutzer die Rolle übernimmt, *nachdem* Sie die Berechtigungen entzogen haben, dann gilt die Zugriffsverweigerungsrichtlinie nicht für diesen Benutzer.

Weitere Informationen zum Verweigern des Zugriffs finden Sie unter [Deaktivieren von Berechtigungen für temporäre Sicherheitsanmeldeinformationen](id_credentials_temp_control-access_disable-perms.md).

**Wichtig**  
Diese Zugriffsverweigerungsrichtlinie gilt für alle Benutzer der angegebenen Rolle, nicht nur für diejenigen mit Konsolensitzungen mit längerer Dauer.

## Mindestberechtigungen für das Entziehen von Sitzungsberechtigungen einer Rolle
<a name="revoke-session-permissions"></a>

Um einer Rolle Sitzungsberechtigungen erfolgreich zu entziehen, müssen Sie über die `PutRolePolicy`-Berechtigung für die Rolle verfügen. Auf diese Weise können Sie der Rolle die Inline-Richtlinie `AWSRevokeOlderSessions` anfügen.

## Widerrufen von Sitzungsberechtigungen
<a name="revoke-session"></a>

Sie können die Sitzungsberechtigungen einer Rolle widerrufen, um jedem Benutzer, der die Rolle übernommen hat, sämtliche Berechtigungen zu verweigern.

**Anmerkung**  
Sie können in IAM keine Rollen bearbeiten, die aus Berechtigungssätzen des IAM Identity Center erstellt wurden. Sie müssen die aktive Berechtigungssatz-Sitzung für einen Benutzer im IAM Identity Center widerrufen. Weitere Informationen finden Sie unter [Widerrufen aktiver IAM-Rollensitzungen, die durch Berechtigungssätze erstellt wurden](https://docs.aws.amazon.com/singlesignon/latest/userguide/useraccess.html#revoke-user-permissions) im *Benutzerhandbuch zum IAM Identity Center*.

**So verweigern Sie sofort sämtliche Berechtigungen für alle aktuellen Benutzer der Anmeldeinformationen der Rolle**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Wählen Sie im Navigationsbereich **Rollen** und anschließend den Namen (nicht das Kontrollkästchen) der Rolle aus, deren Berechtigungen Sie widerrufen möchten.

1. Klicken Sie auf der Seite **Summary (Übersicht)** für die ausgewählte Rolle auf die Registerkarte **Revoke sessions (Sitzungen widerrufen)**.

1. Wählen Sie auf der Registerkarte **Revoke sessions (Sitzungen widerrufen)** die Option **Revoke active sessions (Aktive Sitzungen widerrufen)**.

1. AWS fordert Sie auf, die Aktion zu bestätigen. Aktivieren Sie das Kontrollkästchen **Ich bestätige, dass ich alle aktiven Sitzungen für diese Rolle widerrufe.** und wählen Sie im Dialogfeld **Aktive Sitzungen widerrufen** aus.

   IAM fügt der Rolle dann eine Richtlinie mit dem Namen `AWSRevokeOlderSessions` hinzu. Wenn Sie **Aktive Sitzungen widerrufen** auswählen, verweigert die Richtlinie allen Benutzern, die die Rolle in der Vergangenheit sowie etwa 30 Sekunden in der Zukunft übernommen haben, den Zugriff. Diese zukünftige Zeitwahl berücksichtigt die Verzögerung bei der Umsetzung der Richtlinie, um eine neue Sitzung zu bearbeiten, die vor Inkrafttreten der aktualisierten Richtlinie in einer bestimmten Region erworben oder erneuert wurde. Benutzer, die die Rolle mehr als ca. 30 Sekunden nach der Auswahl von „Aktive Sitzungen widerrufen“ übernehmen, sind hiervon nicht betroffen. Um zu erfahren, warum Änderungen nicht immer sofort sichtbar sind, siehe [Änderungen, die ich vornehme, sind nicht immer direkt sichtbar](troubleshoot.md#troubleshoot_general_eventual-consistency). 

**Anmerkung**  
Wenn Sie später erneut die Option **Aktive Sitzungen widerrufen** auswählen, wird der Datums- und Zeitstempel in der Richtlinie aktualisiert und alle Berechtigungen für Benutzer, die die Rolle vor der neu angegebenen Zeit übernommen haben, werden erneut verweigert.

Gültige Benutzer, deren Sitzungen auf diese Weise aufgehoben wurden, benötigen temporäre Anmeldeinformationen für eine neue Sitzung, um weiterarbeiten zu können. Die Anmeldeinformationen werden AWS CLI zwischengespeichert, bis sie ablaufen. Um die CLI zu zwingen, zwischengespeicherte Anmeldeinformationen, die nicht mehr gültig sind, zu löschen und zu aktualisieren, führen Sie einen der folgenden Befehle aus:

**Linux, macOS oder Unix**

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

**Windows**

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

## Widerrufen von Sitzungsberechtigungen vor einem bestimmten Zeitpunkt
<a name="revoke-session-policy"></a>

 Sie können Sitzungsberechtigungen auch jederzeit Ihrer Wahl widerrufen, indem Sie das SDK AWS CLI oder das SDK verwenden, um einen Wert für den `aws:TokenIssueTime` Schlüssel im Condition-Element einer Richtlinie anzugeben. 

Diese Richtlinie verweigert alle Berechtigungen, wenn der Wert von `aws:TokenIssueTime` vor dem angegebenen Datum und der angegebenen Uhrzeit liegt. Der Wert von `aws:TokenIssueTime` entspricht der präzisen Uhrzeit, zu der die temporären Sicherheitsanmeldeinformationen erstellt wurden. Der `aws:TokenIssueTime` Wert ist nur im Kontext von AWS Anfragen vorhanden, die mit temporären Sicherheitsanmeldedaten signiert wurden. Daher wirkt sich die Deny-Anweisung in der Richtlinie nicht auf Anfragen aus, die mit den langfristigen Anmeldeinformationen des IAM-Benutzers signiert wurden.

Diese Richtlinie kann auch einer Rolle zugeordnet werden. In diesem Fall wirkt sich die Richtlinie nur auf die temporären Sicherheitsanmeldeinformationen aus, die vor dem angegebenen Datum und der angegebenen Uhrzeit von der Rolle erstellt wurden.

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

****  

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

------

Gültige Benutzer, deren Sitzungen auf diese Weise aufgehoben wurden, benötigen temporäre Anmeldeinformationen für eine neue Sitzung, um weiterarbeiten zu können. Die Anmeldeinformationen werden AWS CLI zwischengespeichert, bis sie ablaufen. Um die CLI zu zwingen, zwischengespeicherte Anmeldeinformationen, die nicht mehr gültig sind, zu löschen und zu aktualisieren, führen Sie einen der folgenden Befehle aus:

**Linux, macOS oder Unix**

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

**Windows**

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

# Serviceverknüpfte Rolle aktualisieren
<a name="id_roles_update-service-linked-role"></a>

Die Vorgehensweise zum Bearbeiten einer serviceverknüpften Rolle hängt vom Service ab. Einige Services erlauben möglicherweise das Bearbeiten der Berechtigungen für eine serviceverknüpfte Rolle über die Servicekonsole, eine API oder die CLI. Da möglicherweise verschiedene Entitäten auf die Rolle verweisen, kann der Rollenname nach der Erstellung einer serviceverknüpften Rolle nicht bearbeitet werden. Sie können die Beschreibung beliebiger Rollen über die IAM-Konsole, eine API oder die CLI bearbeiten.

Informationen darüber, welche Services die Verwendung von serviceverknüpften Rollen unterstützen, finden Sie unter [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md). Suchen Sie nach den Services, für die **Ja** in der Spalte **Serviceverknüpfte Rolle** angegeben ist. Um zu erfahren, ob der Service das Bearbeiten der serviceverknüpften Rolle unterstützt, wählen Sie den Link **Yes** aus, um die Dokumentation zur serviceverknüpften Rolle dieses Services anzuzeigen.

## Bearbeiten der Beschreibung einer serviceverknüpften Rolle (Konsole)
<a name="edit-service-linked-role-iam-console"></a>

Sie können die IAM-Konsole für das Bearbeiten der Beschreibung einer serviceverknüpften Rolle verwenden.

**So bearbeiten Sie die Beschreibung einer serviceverknüpften Rolle (Konsole)**

1. Wählen Sie im Navigationsbereich der IAM Console **Roles** (Rollen) aus.

1. Wählen Sie den Namen der zu ändernden Rolle.

1. Wählen Sie neben **Role description** ganz rechts **Edit**. 

1. Geben Sie eine neue Beschreibung im Dialogfeld ein und klicken Sie auf **Save (Speichern)**.

## Bearbeiten der Beschreibung einer serviceverknüpften Rolle (AWS CLI)
<a name="edit-service-linked-role-iam-cli"></a>

Sie können IAM-Befehle von verwenden, AWS CLI um die Beschreibung einer serviceverknüpften Rolle zu bearbeiten.

**So ändern Sie die Beschreibung einer serviceverknüpften Rolle (AWS CLI)**

1. (Optional) Um die aktuelle Beschreibung einer Rolle anzuzeigen, führen Sie die folgenden Befehle aus:

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

   Verwenden Sie den Rollennamen, nicht den ARN, um sich auf Rollen mit den CLI-Befehlen zu beziehen. Wenn eine Rolle zum Beispiel folgenden ARN hat: `arn:aws:iam::123456789012:role/myrole`, verweisen Sie auf die Rolle als **myrole**.

1. Um die Beschreibung einer serviceverknüpften Rolle zu aktualisieren, führen Sie den folgenden Befehl aus:

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

## Bearbeiten einer Beschreibung einer serviceverknüpften Rolle (API)AWS
<a name="edit-service-linked-role-iam-api"></a>

Sie können die AWS API verwenden, um die Beschreibung einer dienstbezogenen Rolle zu bearbeiten.

**Um die Beschreibung einer dienstbezogenen Rolle (AWS API) zu ändern**

1. (Optional:) Um die aktuelle Beschreibung einer Rolle anzuzeigen, rufen Sie die folgende Operation auf und geben den Namen der Rolle an:

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

1. Um die Beschreibung einer Rolle zu ändern, rufen Sie die folgende Operation auf und geben den Namen (sowie optional eine Beschreibung) der Rolle an: 

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

# Rollenvertrauensrichtlinie aktualisieren
<a name="id_roles_update-role-trust-policy"></a>

Um zu ändern, wer eine Rolle übernehmen kann, müssen Sie die Vertrauensrichtlinie der Rolle bearbeiten. Sie können die Vertrauensrichtlinie für eine *[serviceverknüpfte Rolle](id_roles.md#iam-term-service-linked-role)* nicht ändern.

**Hinweise**  
Wenn ein Benutzer als Auftraggeber in der Vertrauensrichtlinie einer Rolle aufgeführt ist, aber die Rolle nicht übernehmen kann, überprüfen Sie die [Berechtigungsgrenze](access_policies_boundaries.md) des Benutzers. Wenn eine Berechtigungsgrenze für den Benutzer festgelegt ist, dann muss sie die `sts:AssumeRole`-Aktion zulassen.
Damit Benutzer die aktuelle Rolle innerhalb einer Rollensitzung wieder übernehmen können, geben Sie den Rollen-ARN oder AWS-Konto ARN als Principal in der Rollenvertrauensrichtlinie an. AWS-Services die Rechenressourcen wie Amazon EC2, Amazon ECS, Amazon EKS und Lambda bereitstellen, stellen temporäre Anmeldeinformationen bereit und aktualisieren diese Anmeldeinformationen automatisch. Dadurch wird sichergestellt, dass Sie immer über gültige Anmeldeinformationen verfügen. Für diese Dienste ist es nicht erforderlich, die aktuelle Rolle erneut anzunehmen, um temporäre Anmeldeinformationen zu erhalten. Wenn Sie jedoch beabsichtigen, [Sitzungs-Tags](id_session-tags.md) oder eine [Sitzungsrichtlinie](access_policies.md#policies_session) zu übergeben, müssen Sie die aktuelle Rolle erneut annehmen.


## Aktualisierung einer Rollenvertrauensrichtlinie (Konsole)
<a name="id_roles_update-trust-policy-console"></a>

**Um die Vertrauensrichtlinie einer Rolle in der zu ändern AWS-Managementkonsole**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie im Navigationsbereich der IAM Console **Roles** (Rollen) aus.

1. Wählen Sie in der Rollenliste in Ihrem Konto den Namen der zu ändernden Rolle.

1. Wählen Sie die Registerkarte **Trust Relationships** (Vertrauensstellungen) und dann **Edit trust policy** (Vertrauensrichtlinie bearbeiten) aus.

1. Bearbeiten Sie die Vertrauensrichtlinie nach Bedarf. Um weitere Auftraggeber hinzuzufügen, die die Rolle übernehmen können, geben Sie sie im `Principal`-Element an. Der folgende Richtlinienausschnitt zeigt beispielsweise, wie AWS-Konten in dem Element auf zwei verwiesen wird: `Principal`

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

   Wenn Sie einen Auftraggeber in einem anderen Konto angeben, ist das Hinzufügen eines Kontos zur Vertrauensrichtlinie einer Rolle nur die Hälfte der Einrichtung einer kontoübergreifenden Vertrauensbeziehung. Standardmäßig kann kein Benutzer in den vertrauenswürdigen Konten die Rolle übernehmen. Der Administrator für das neue vertrauenswürdige Konto muss den Benutzern die Berechtigung erteilen, die Rolle zu übernehmen. Dazu muss der Administrator eine Richtlinie erstellen oder bearbeiten, die an den Benutzer angehängt ist, um dem Benutzer den Zugriff auf die Aktion `sts:AssumeRole` zu ermöglichen. Weitere Informationen finden Sie im folgenden Verfahren oder unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).

   Der folgende Richtlinienausschnitt zeigt, wie auf zwei AWS Dienste im Element verwiesen wird: `Principal`

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

1. Wenn Sie die Bearbeitung Ihrer Vertrauensrichtlinie abgeschlossen haben, wählen Sie **Update policy** (Richtlinie aktualisieren), um Ihre Änderungen zu speichern.

   Weitere Informationen über die Richtlinienstruktur und -syntax finden Sie unter [Richtlinien und Berechtigungen in AWS Identity and Access Management](access_policies.md) und [Referenz zum IAM-JSON-Richtlinienelement](reference_policies_elements.md).

**So erteilen Sie Benutzern in einem vertrauenswürdigen Konto die Berechtigung zur Verwendung der Rolle (Konsole)**

Weitere Informationen und Details zu dieser Vorgehensweise finden Sie unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).

1. Melden Sie sich bei dem vertrauenswürdigen externen Anbieter an. AWS-Konto

1. Legen Sie fest, ob die Berechtigungen einem Benutzer oder einer Gruppe angefügt werden. Wählen Sie im Navigationsbereich der IAM-Konsole entsprechend **Users** (Benutzer) oder **Groups** (Gruppen).

1. Wählen Sie den Namen des Benutzers oder der Gruppe aus, der Sie die Zugriffsberechtigung erteilen möchten, und klicken Sie auf die Registerkarte **Permissions (Berechtigungen)**.

1. Führen Sie eine der folgenden Aktionen aus:
   + Um eine vom Kunden verwaltete Richtlinien zu bearbeiten, wählen Sie den Namen der Richtlinie, **Edit policy (Richtlinie bearbeiten)** und die Registerkarte **JSON**. Sie können eine AWS verwaltete Richtlinie nicht bearbeiten. AWS Verwaltete Richtlinien werden mit dem AWS Symbol (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/policy_icon.png)) angezeigt. Weitere Informationen zum Unterschied zwischen von AWS und vom Kunden verwaltete Richtlinien finden Sie unter [Verwaltete Richtlinien und eingebundene Richtlinien](access_policies_managed-vs-inline.md).
   + Um eine Inlinerichtlinie zu bearbeiten, wählen Sie den Pfeil neben dem Namen der Richtlinie und dann **Edit policy (Richtlinie bearbeiten)**.

1. Fügen Sie im Richtlinien-Editor ein neues `Statement`-Element hinzu, welches folgende Angaben macht:

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

   Ersetzen Sie den ARN in der Anweisung durch den ARN der Rolle, die der Benutzer übernehmen kann.

1. Folgen Sie den Anweisungen auf dem Bildschirm, um die Bearbeitung der Richtlinie abzuschließen. 

## Aktualisierung einer Rollenvertrauensrichtlinie (AWS CLI)
<a name="id_roles-update-trust-policy-cli"></a>

Sie können das verwenden AWS CLI , um zu ändern, wer eine Rolle übernehmen kann.

**So ändern Sie eine Rollenvertrauensrichtinie (AWS CLI)**

1. (Optional) Wenn Sie den Namen der Rolle, die Sie ändern möchten, nicht kennen, führen Sie den folgenden Befehl aus, um die Rollen im Konto aufzulisten:
   + [aws iam list-roles](https://docs.aws.amazon.com/cli/latest/reference/iam/list-roles.html)

1. (Optional) Um die aktuelle Vertrauensrichtlinie einer Rolle anzuzeigen, führen Sie den folgenden Befehl aus:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Um die vertrauenswürdigen Auftraggeber zu ändern, die auf die Rolle zugreifen können, erstellen Sie eine Textdatei mit der aktualisierten Vertrauensrichtlinie. Sie können zum Erstellen der Richtlinie einen beliebigen Texteditor verwenden.

   Die folgende Vertrauensrichtlinie zeigt, wie auf zwei AWS-Konten im `Principal`-Element verwiesen wird. Auf diese Weise können Benutzer innerhalb von zwei getrennten AWS-Konten Benutzern diese Rolle übernehmen.

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

****  

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

------

   Wenn Sie einen Auftraggeber in einem anderen Konto angeben, ist das Hinzufügen eines Kontos zur Vertrauensrichtlinie einer Rolle nur die Hälfte der Einrichtung einer kontoübergreifenden Vertrauensbeziehung. Standardmäßig kann kein Benutzer in den vertrauenswürdigen Konten die Rolle übernehmen. Der Administrator für das neue vertrauenswürdige Konto muss den Benutzern die Berechtigung erteilen, die Rolle zu übernehmen. Dazu muss der Administrator eine Richtlinie erstellen oder bearbeiten, die an den Benutzer angehängt ist, um dem Benutzer den Zugriff auf die Aktion `sts:AssumeRole` zu ermöglichen. Weitere Informationen finden Sie im folgenden Verfahren oder unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).

1. Um die soeben erstellte Datei zur Aktualisierung der Vertrauensrichtlinie zu verwenden, führen Sie den folgenden Befehl aus:
   + [war ich update-assume-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/update-assume-role-policy.html)

**So erteilen Sie Benutzern in einem vertrauenswürdigen Konto die Berechtigung zur Verwendung der Rolle (AWS CLI)**

Weitere Informationen und Details zu dieser Vorgehensweise finden Sie unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).

1. Erstellen Sie eine JSON-Datei, die eine Berechtigungsrichtlinie enthält, die Berechtigungen für die Übernahme der Rolle erteilt. Die folgende Richtlinie enthält beispielsweise die erforderlichen Mindestberechtigungen:

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

****  

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

------

   Ersetzen Sie den ARN in der Anweisung durch den ARN der Rolle, die der Benutzer übernehmen kann.

1. Führen Sie den folgenden Befehl aus, um die JSON-Datei, die die Vertrauensrichtlinie enthält, in IAM hochzuladen:
   + [aws iam create-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy.html)

   Die Ausgabe dieses Befehls enthält den ARN der Richtlinie. Notieren Sie sich diesen ARN, da Sie ihn zu einem späteren Zeitpunkt brauchen. 

1. Legen Sie fest, welchem Benutzer oder welcher Gruppe Sie die Richtlinie anfügen. Wenn Sie den Namen des betreffenden Benutzers oder der Gruppe nicht kennen, geben Sie einen der folgenden Befehle ein, um die Benutzer oder Gruppen im Konto aufzulisten:
   + [aws iam list-users](https://docs.aws.amazon.com/cli/latest/reference/iam/list-users.html)
   + [aws iam list-groups](https://docs.aws.amazon.com/cli/latest/reference/iam/list-groups.html)

1. Verwenden Sie einen der folgenden Befehle, um die im vorherigen Schritt erstellte Richtlinie an einen Benutzer oder eine Gruppe anzufügen:
   + [war ich attach-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html)
   + [war ich attach-group-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-group-policy.html)

## Aktualisierung einer Rollenvertrauensrichtlinie (AWS API)
<a name="id_roles-update-trust-policy-api"></a>

Sie können die AWS API verwenden, um zu ändern, wer eine Rolle übernehmen kann.

**Um eine Vertrauensrichtlinie (AWS API) für Rollen zu ändern**

1. (Optional) Wenn Sie den Namen der Rolle, die Sie ändern möchten, nicht kennen, rufen Sie die folgende Operation auf, um die Rollen im Konto aufzulisten:
   + [ListRoles](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRoles.html)

1. (Optional) Um die aktuelle Vertrauensrichtlinie einer Rolle anzuzeigen, rufen Sie die folgende Operation auf:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)

1. Um die vertrauenswürdigen Auftraggeber zu ändern, die auf die Rolle zugreifen können, erstellen Sie eine Textdatei mit der aktualisierten Vertrauensrichtlinie. Sie können zum Erstellen der Richtlinie einen beliebigen Texteditor verwenden.

   Die folgende Vertrauensrichtlinie zeigt, wie auf zwei AWS-Konten im `Principal`-Element verwiesen wird. Auf diese Weise können Benutzer innerhalb von zwei getrennten AWS-Konten Benutzern diese Rolle übernehmen.

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

****  

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

------

   Wenn Sie einen Auftraggeber in einem anderen Konto angeben, ist das Hinzufügen eines Kontos zur Vertrauensrichtlinie einer Rolle nur die Hälfte der Einrichtung einer kontoübergreifenden Vertrauensbeziehung. Standardmäßig kann kein Benutzer in den vertrauenswürdigen Konten die Rolle übernehmen. Der Administrator für das neue vertrauenswürdige Konto muss den Benutzern die Berechtigung erteilen, die Rolle zu übernehmen. Dazu muss der Administrator eine Richtlinie erstellen oder bearbeiten, die an den Benutzer angehängt ist, um dem Benutzer den Zugriff auf die Aktion `sts:AssumeRole` zu ermöglichen. Weitere Informationen finden Sie im folgenden Verfahren oder unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).

1. Um die soeben erstellte Datei zur Aktualisierung der Vertrauensrichtlinie zu verwenden, führen Sie die folgende Operation aus:
   + [UpdateAssumeRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAssumeRolePolicy.html)

**Um Benutzern mit einem vertrauenswürdigen externen Konto die Nutzung der Rolle (AWS API) zu ermöglichen**

Weitere Informationen und Details zu dieser Vorgehensweise finden Sie unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).

1. Erstellen Sie eine JSON-Datei, die eine Berechtigungsrichtlinie enthält, die Berechtigungen für die Übernahme der Rolle erteilt. Die folgende Richtlinie enthält beispielsweise die erforderlichen Mindestberechtigungen:

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

****  

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

------

   Ersetzen Sie den ARN in der Anweisung durch den ARN der Rolle, die der Benutzer übernehmen kann.

1. Führen Sie die folgende Operation aus, um die JSON-Datei, die die Vertrauensrichtlinie enthält, in IAM hochzuladen:
   + [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)

   Die Ausgabe dieser Operation enthält den ARN der Richtlinie. Notieren Sie sich diesen ARN, da Sie ihn zu einem späteren Zeitpunkt brauchen. 

1. Legen Sie fest, welchem Benutzer oder welcher Gruppe Sie die Richtlinie anfügen. Wenn Sie den Namen des betreffenden Benutzers oder der Gruppe nicht kennen, rufen Sie eine der folgenden Operationen auf, um die Benutzer oder Gruppen im Konto aufzulisten:
   + [ListUsers](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListUsers.html)
   + [ListGroups](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListGroups.html)

1. Rufen Sie eine der folgenden Operationen auf, um die im vorherigen Schritt erstellte Richtlinie an einen Benutzer oder eine Gruppe anzufügen:
   +  API: [AttachUserPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachUserPolicy.html)
   + [AttachGroupPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachGroupPolicy.html)

# Berechtigungen für eine Rolle aktualisieren
<a name="id_roles_update-role-permissions"></a>

Verwenden Sie die folgenden Verfahren, um die Berechtigungsrichtlinien und Berechtigungsgrenzen einer Rolle zu aktualisieren.

## Voraussetzung: Rollenzugriff anzeigen
<a name="roles-modify_prerequisites"></a>

Bevor Sie die Berechtigungen für eine Rolle ändern, sollten Sie ihre kürzliche Service-Level-Aktivität überprüfen. Das ist wichtig, da Sie keinem Auftraggeber (Person oder Anwendung) einen noch verwendeten Zugriff entziehen möchten. Weitere Informationen zum Anzeigen der Informationen zum letzten Zugriff finden Sie unter [Verfeinern Sie die Berechtigungen für AWS die Verwendung der zuletzt abgerufenen Informationen](access_policies_last-accessed.md).

## Aktualisieren der Berechtigungsrichtlinie für eine Rolle
<a name="id_roles_update-role-permissions-policy"></a>

Um die von der Rolle zugelassenen Berechtigungen zu ändern, modifizieren Sie die Berechtigungsrichtlinie (oder Berechtigungsrichtlinien) der Rolle. Sie können die Berechtigungsrichtlinie für eine *[serviceverknüpfte Rolle](id_roles.md#iam-term-service-linked-role)* in IAM nicht ändern. Möglicherweise können Sie die Berechtigungsrichtlinie innerhalb des Service ändern, der von der Rolle abhängt. Um zu überprüfen, ob ein Service dieses Feature unterstützt, lesen Sie [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md) und suchen Sie nach den Services mit **Yes** (Ja) in der Spalte **Service-linked roles** (Serviceverknüpfte Rollen). Wählen Sie über einen Link **Ja** aus, um die Dokumentation zu einer serviceverknüpften Rolle für diesen Service anzuzeigen.

### Aktualisieren einer Rollen-Berechtigungsrichtlinie (Konsole)
<a name="id_roles_update-role-permissions-policy-console"></a>

**So ändern Sie die Berechtigungen einer Rolle (Konsole)**

1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

1. Wählen Sie im Navigationsbereich der IAM Console **Roles** (Rollen) aus.

1. Wählen Sie den Namen der zu ändernden Rolle aus und klicken Sie anschließend auf die Registerkarte **Permissions (Berechtigungen)**.

1. Führen Sie eine der folgenden Aktionen aus:
   + Um eine vorhandene vom Kunden verwaltete Richtlinien zu bearbeiten, wählen Sie den Namen der Richtlinie und dann **Edit policy (Richtline bearbeiten)**.
**Anmerkung**  
Sie können eine AWS verwaltete Richtlinie nicht bearbeiten. AWS Verwaltete Richtlinien werden mit dem AWS Symbol (![\[Orange cube icon indicating a policy is managed by AWS.\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/policy_icon.png)) angezeigt. Weitere Informationen zum Unterschied zwischen AWS verwalteten Richtlinien und kundenverwalteten Richtlinien finden Sie unter[Verwaltete Richtlinien und eingebundene Richtlinien](access_policies_managed-vs-inline.md). 
   + Um Rolle eine vorhandene verwaltete Richtlinie an die Rolle anzufügen, wählen Sie **Add permissions** (Berechtigungen hinzufügen) und dann **Attach policies** (Richtlinien anfügen).
   + Um eine bestehende Inline-Richtlinie zu bearbeiten, erweitern Sie die Richtlinie und wählen Sie **Edit** (Bearbeiten).
   + Um eine neue Inline-Richtlinie einzubetten, wählen Sie **Add permissions** (Berechtigungen hinzufügen) und dann **Create inline policy** (Inline-Richtlinie erstellen). 
   + Um eine vorhandene Richtlinie aus der Rolle zu entfernen, aktivieren Sie das Kontrollkästchen neben dem Richtliniennamen und wählen Sie dann **Entfernen**.

### Aktualisieren einer Rollen-Berechtigungsrichtlinie (AWS CLI)
<a name="id_roles_update_permissions-policy-cli"></a>

Um die von der Rolle zugelassenen Berechtigungen zu ändern, modifizieren Sie die Berechtigungsrichtlinie (oder Berechtigungsrichtlinien) der Rolle. Sie können die Berechtigungsrichtlinie für eine *[serviceverknüpfte Rolle](id_roles.md#iam-term-service-linked-role)* in IAM nicht ändern. Möglicherweise können Sie die Berechtigungsrichtlinie innerhalb des Service ändern, der von der Rolle abhängt. Um zu überprüfen, ob ein Service dieses Feature unterstützt, lesen Sie [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md) und suchen Sie nach den Services mit **Yes** (Ja) in der Spalte **Service-linked roles** (Serviceverknüpfte Rollen). Wählen Sie über einen Link **Ja** aus, um die Dokumentation zu einer serviceverknüpften Rolle für diesen Service anzuzeigen.

**So ändern Sie die Berechtigungen einer Rolle (AWS CLI)**

1. (Optional) Um die aktuell mit einer Rolle verknüpften Berechtigungen anzuzeigen, führen Sie die folgenden Befehle aus:

   1. [Unser Ziel ist es,](https://docs.aws.amazon.com/cli/latest/reference/iam/list-role-policies.html) Inline-Richtlinien list-role-policies aufzulisten

   1. [aws möchte verwaltete list-attached-role-policies](https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-role-policies.html) Richtlinien auflisten

1. Der Befehl zum Aktualisieren von Berechtigungen der Rolle unterscheidet sich je nachdem, ob Sie eine verwaltete Inlinerichtlinie aktualisieren.

   Wenn Sie eine verwaltete Richtlinie aktualisieren möchten, führen Sie den folgenden Befehl aus, um eine neue Version der verwalteten Richtlinie zu erstellen:
   + [war ich create-policy-version](https://docs.aws.amazon.com/cli/latest/reference/iam/create-policy-version.html)

   Um eine Inline-Richtlinie zu aktualisieren, führen Sie den folgenden Befehl aus:
   + [war ich put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)

### Aktualisierung einer Richtlinie für Rollenberechtigungen (AWS API)
<a name="id_roles_update_permissions-policy-api"></a>

Um die von der Rolle zugelassenen Berechtigungen zu ändern, modifizieren Sie die Berechtigungsrichtlinie (oder Berechtigungsrichtlinien) der Rolle. Sie können die Berechtigungsrichtlinie für eine *[serviceverknüpfte Rolle](id_roles.md#iam-term-service-linked-role)* in IAM nicht ändern. Möglicherweise können Sie die Berechtigungsrichtlinie innerhalb des Service ändern, der von der Rolle abhängt. Um zu überprüfen, ob ein Service dieses Feature unterstützt, lesen Sie [AWS Dienste, die mit IAM funktionieren](reference_aws-services-that-work-with-iam.md) und suchen Sie nach den Services mit **Yes** (Ja) in der Spalte **Service-linked roles** (Serviceverknüpfte Rollen). Wählen Sie über einen Link **Ja** aus, um die Dokumentation zu einer serviceverknüpften Rolle für diesen Service anzuzeigen.

**Um die von einer Rolle (AWS API) erlaubten Berechtigungen zu ändern**

1. (Optional) Um die aktuell mit einer Rolle verknüpften Berechtigungen anzuzeigen, rufen Sie die folgenden Operationen auf:

   1. [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html)um Inline-Richtlinien aufzulisten

   1. [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html)um verwaltete Richtlinien aufzulisten

1. Die Operation zum Aktualisieren von Berechtigungen der Rolle unterscheidet sich je nachdem, ob Sie eine verwaltete oder eine Inline-Richtlinie aktualisieren.

   Wenn Sie eine verwaltete Richtlinie aktualisieren möchten, rufen Sie die folgende Operation auf, um eine neue Version der verwalteten Richtlinie zu erstellen:
   + [CreatePolicyVersion](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicyVersion.html)

   Um eine Inline-Richtlinie zu aktualisieren, rufen Sie die folgende Operation auf:
   + [PutRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html)

## Aktualisieren der Berechtigungsgrenze für eine Rolle
<a name="id_roles_update-role-permissions-boundary"></a>

Um die maximalen Berechtigungen zu ändern, die für eine Rolle zulässig sind, ändern Sie die [Berechtigungsgrenze](access_policies_boundaries.md) der Rolle.

### Aktualisieren einer Rollen-Berechtigungsgrenze (Konsole)
<a name="id_roles_update-permissions-boundary-console"></a>

**Ändern der Richtlinie zum Festlegen der Berechtigungsgrenze für eine Rolle**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie im Navigationsbereich **Rollen**.

1. Wählen Sie den Namen der Rolle mit der [Berechtigungsgrenze](access_policies_boundaries.md), die Sie ändern möchten. 

1. Wählen Sie die Registerkarte **Berechtigungen**. Falls erforderlich, öffnen Sie den Abschnitt **Permissions boundary (Berechtigungsgrenze)** und wählen **Change boundary (Grenze ändern)**.

1. Wählen Sie die Richtlinie aus, die Sie für die Berechtigungsgrenze verwenden möchten.

1. Wählen Sie **Change boundary (Grenze ändern)**.

   Ihre Änderungen werden erst wirksam, wenn das nächste Mal jemand diese Rolle annimmt.

### Aktualisieren einer Rollen-Berechtigungsgrenze (AWS CLI)
<a name="id_roles_update_permissions-boundary-cli"></a>

**Ändern der verwalteten Richtlinie zum Festlegen der Berechtigungsgrenze für eine Rolle (AWS CLI)**

1. (Optional) Um die aktuelle [Berechtigungsgrenze](access_policies_boundaries.md) einer Rolle anzuzeigen, führen Sie den folgenden Befehl aus: 
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Um eine andere verwaltete Richtlinie zum Aktualisieren der Berechtigungsgrenze für eine Rolle zu verwenden, führen Sie den folgenden Befehl aus: 
   + [war ich put-role-permissions-boundary](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-permissions-boundary.html)

   Eine Rolle kann nur eine verwaltete Richtlinie als Berechtigungsgrenze festlegen. Wenn Sie die Berechtigungsgrenze ändern, ändern Sie die maximal zulässigen Berechtigungen für eine Rolle.

### Aktualisierung einer Rollenberechtigungsgrenze (AWS API)
<a name="id_roles_update-permissions-boundary-api"></a>

**Um die verwaltete Richtlinie zu ändern, mit der die Berechtigungsgrenze für eine Rolle festgelegt wurde (AWS API)**

1. (Optional) Um die aktuelle [Berechtigungsgrenze](access_policies_boundaries.md) einer Rolle anzuzeigen, führen Sie die folgende Operation aus: 
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)

1. Um eine andere verwaltete Richtlinie zum Aktualisieren der Berechtigungsgrenze für eine Rolle zu verwenden, führen Sie die folgende Operation aus: 
   + [PutRolePermissionsBoundary](https://docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePermissionsBoundary.html)

   Eine Rolle kann nur eine verwaltete Richtlinie als Berechtigungsgrenze festlegen. Wenn Sie die Berechtigungsgrenze ändern, ändern Sie die maximal zulässigen Berechtigungen für eine Rolle.

# Aktualisieren der Einstellungen für eine Rolle
<a name="id_roles_update-role-settings"></a>

Verwenden Sie die folgenden Verfahren, um die Beschreibung einer Rolle zu aktualisieren oder die maximale Sitzungsdauer für eine Rolle zu ändern.

## Rollenbeschreibung aktualisieren
<a name="id_roles_update-description"></a>

Um die Beschreibung einer Rolle zu ändern, modifizieren Sie den Text der Beschreibung.

### Aktualisieren einer Rollenbeschreibung (Konsole)
<a name="id_roles_update-description-console"></a>

**So ändern Sie die Beschreibung einer Rolle (Konsole)**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie im Navigationsbereich der IAM Console **Roles** (Rollen) aus.

1. Wählen Sie den Namen der zu ändernden Rolle.

1. Wählen Sie im Abschnitt **Summary** (Zusammenfassung) **Edit** (Bearbeiten).

1. Geben Sie eine neue Beschreibung im Dialogfeld ein und wählen Sie **Save changes** (Änderungen speichern).

### Aktualisieren einer Rollenbeschreibung (AWS CLI)
<a name="id_roles_update-description-cli"></a>

**So ändern Sie die Beschreibung einer Rolle (AWS CLI)**

1. (Optional) Um die aktuelle Beschreibung einer Rolle anzuzeigen, führen Sie den folgenden Befehl aus:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Um die Beschreibung einer Rolle zu aktualisieren, führen Sie den folgenden Befehl mit dem Beschreibungsparameter aus:
   + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html)

### Aktualisierung einer Rollenbeschreibung (AWS API)
<a name="id_roles_update-description-api"></a>

**Um die Beschreibung einer Rolle (AWS API) zu ändern**

1. (Optional) Um die aktuelle Beschreibung einer Rolle anzuzeigen, rufen Sie die folgende Operation auf:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Um die Beschreibung einer Rolle zu aktualisieren, rufen Sie die folgende Operation mit dem Beschreibungsparameter auf:
   + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html)

## Aktualisieren der maximalen Sitzungsdauer für eine Rolle
<a name="id_roles_update-session-duration"></a>

Um die Einstellung für die maximale Sitzungsdauer für Rollen anzugeben, die über die Konsole, die oder die AWS CLI AWS API übernommen werden, ändern Sie den Einstellungswert für die maximale Sitzungsdauer. Diese Einstellung kann einen Wert zwischen 1 Stunde und 12 Stunden haben. Wenn Sie keinen Wert angeben, wird der maximale Standardwert von einer Stunde angewendet. Diese Einstellung schränkt nicht die Anzahl der Sitzungen ein, die von AWS Diensten angenommen werden.

### Aktualisierung der maximalen Rollensitzungsdauer (Konsole)
<a name="id_roles_update-session-duration-console"></a><a name="id_roles_modify_max-session"></a>

**Um die Einstellung für die maximale Sitzungsdauer für Rollen zu ändern AWS CLI, die über die Konsole oder AWS API (Konsole) übernommen werden**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie im Navigationsbereich der IAM Console **Roles** (Rollen) aus.

1. Wählen Sie den Namen der zu ändernden Rolle.

1. Wählen Sie im Abschnitt **Summary** (Zusammenfassung), **Edit** (Bearbeiten).

1. Wählen Sie für **Maximum session duration** (Maximale Sitzungsdauer) einen Wert. Alternativ wählen Sie **Custom duration** (Benutzerdefinierte Dauer) und geben einen Wert (in Sekunden) ein.

1. Wählen Sie **Änderungen speichern ** aus.

   Ihre Änderungen werden erst wirksam, wenn das nächste Mal jemand diese Rolle annimmt. Weitere Informationen dazu, wie Sie bestehende Sitzungen für diese Rolle widerrufen, finden Sie unter [Temporäre Sicherheitsanmeldeinformationen der IAM-Rolle widerrufen](id_roles_use_revoke-sessions.md).

In der AWS-Managementkonsole dauern IAM-Benutzersitzungen standardmäßig 12 Stunden. IAM-Benutzer, die in der Konsole die Rolle wechseln, erhalten die maximale Sitzungsdauer der Rolle oder die verbleibende Zeit in der Sitzung des Benutzers, je nachdem, was kürzer ist.

Jeder, der die Rolle über die AWS API AWS CLI oder übernimmt, kann bis zu diesem Maximum eine längere Sitzung beantragen. Die Einstellung `MaxSessionDuration` bestimmt die maximale Dauer der Rollensitzung, die angefordert werden kann.
+  AWS CLI Verwenden Sie den `duration-seconds` Parameter, um eine Sitzungsdauer anzugeben. Weitere Informationen hierzu finden Sie unter [Zu einer IAM-Rolle wechseln (AWS CLI)](id_roles_use_switch-role-cli.md).
+ Verwenden Sie den `DurationSeconds` Parameter, um eine Sitzungsdauer mithilfe der AWS API anzugeben. Weitere Informationen hierzu finden Sie unter [Zu einer IAM-Rolle (AWS API) wechseln](id_roles_use_switch-role-api.md). 

### Aktualisierung der maximalen Rollensitzungsdauer (AWS CLI)
<a name="id_roles_update-session-duration-cli"></a>

**Anmerkung**  
Jeder, der die Rolle von der API AWS CLI oder übernimmt, kann den `duration-seconds` CLI-Parameter oder den `DurationSeconds` API-Parameter verwenden, um eine längere Sitzung anzufordern. Die Einstellung `MaxSessionDuration` bestimmt die maximale Dauer der Rollensitzung, die mit dem `DurationSeconds`-Parameter angefordert werden kann. Wenn Benutzer keinen Wert für den `DurationSeconds`-Parameter angeben, sind ihre Sicherheitsanmeldeinformationen eine Stunde lang gültig.

**Um die Einstellung für die maximale Sitzungsdauer für Rollen zu ändern, die mit AWS CLI (AWS CLI) übernommen werden**

1. (Optional) Um die aktuelle maximale Sitzungsdauer für eine Rolle anzuzeigen, führen Sie den folgenden Befehl aus:
   + [aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)

1. Um die maximale Sitzungsdauer einer Rolle zu aktualisieren, führen Sie den folgenden Befehl mit dem CLI-Parameter `max-session-duration` oder dem API-Parameter `MaxSessionDuration` aus:
   + [aws iam update-role](https://docs.aws.amazon.com/cli/latest/reference/iam/update-role.html)

   Ihre Änderungen werden erst wirksam, wenn das nächste Mal jemand diese Rolle annimmt. Weitere Informationen dazu, wie Sie bestehende Sitzungen für diese Rolle widerrufen, finden Sie unter [Temporäre Sicherheitsanmeldeinformationen der IAM-Rolle widerrufen](id_roles_use_revoke-sessions.md).

### Aktualisierung der maximalen Rollensitzungsdauer (AWS API)
<a name="id_roles_update-session-duration-api"></a>

**Anmerkung**  
Jeder, der die Rolle von der API AWS CLI oder übernimmt, kann den `duration-seconds` CLI-Parameter oder den `DurationSeconds` API-Parameter verwenden, um eine längere Sitzung anzufordern. Die Einstellung `MaxSessionDuration` bestimmt die maximale Dauer der Rollensitzung, die mit dem `DurationSeconds`-Parameter angefordert werden kann. Wenn Benutzer keinen Wert für den `DurationSeconds`-Parameter angeben, sind ihre Sicherheitsanmeldeinformationen eine Stunde lang gültig.

**Um die Einstellung für die maximale Sitzungsdauer für Rollen zu ändern, die mithilfe der API (AWS API) übernommen werden**

1. (Optional) Um die aktuelle maximale Sitzungsdauer für eine Rolle anzuzeigen, rufen Sie die folgende Operation auf:
   + [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) 

1. Um die maximale Sitzungsdauer einer Rolle zu aktualisieren, rufen Sie die folgende Operation mit dem CLI-Parameter `max-sessionduration` oder dem API-Parameter `MaxSessionDuration` auf:
   + [UpdateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRole.html)

   Ihre Änderungen werden erst wirksam, wenn das nächste Mal jemand diese Rolle annimmt. Weitere Informationen dazu, wie Sie bestehende Sitzungen für diese Rolle widerrufen, finden Sie unter [Temporäre Sicherheitsanmeldeinformationen der IAM-Rolle widerrufen](id_roles_use_revoke-sessions.md).

# Rollen oder Instance-Profile löschen
<a name="id_roles_manage_delete"></a>

Wenn Sie eine Rolle nicht mehr benötigen, empfehlen wir, dass Sie die Rolle und die zugehörigen Berechtigungen löschen. Auf diese Weise haben Sie keine ungenutzte Entität, die nicht aktiv überwacht oder verwaltet wird. 

Wenn die Rolle einer EC2-Instance zugeordnet wurde, können Sie die Rolle auch aus dem Instance-Profil entfernen und dieses dann löschen.

**Warnung**  
Stellen Sie sicher, dass keine Amazon EC2 Instances mit der Rolle oder dem Instance-Profil ausgeführt werden, die Sie löschen möchten. Wenn Sie eine Rolle oder ein Instanceprofil löschen, das einer laufenden Instance zugeordnet ist, werden alle Anwendungen unterbrochen, die auf der Instance ausgeführt werden.

Wenn Sie eine Rolle nicht dauerhaft löschen möchten, können Sie sie deaktivieren. Ändern Sie dazu die Richtlinien der Rolle und widerrufen Sie dann alle aktuellen Sitzungen. Sie könnten der Rolle beispielsweise eine Richtlinie hinzufügen, die allen den Zugriff verweigert. AWS Sie können die Vertrauensrichtlinie auch bearbeiten, um jeder Person, die versucht, die Rolle zu übernehmen, den Zugriff zu verweigern. Weitere Informationen zum Widerrufen von Sitzungen finden Sie unter [Temporäre Sicherheitsanmeldeinformationen der IAM-Rolle widerrufen](id_roles_use_revoke-sessions.md).

**Topics**
+ [Rollenzugriff anzeigen](#roles-delete_prerequisites)
+ [Löschen einer serviceverknüpften Rolle](#id_roles_manage_delete_slr)
+ [Löschen einer IAM-Rolle (Konsole)](#roles-managingrole-deleting-console)
+ [Erstellen einer IAM-Rolle (AWS CLI)](#roles-managingrole-deleting-cli)
+ [Löschen einer IAM-Rolle (AWS API)](#roles-managingrole-deleting-api)
+ [Ähnliche Informationen](#roles-managingrole-deleting-related-info)

## Rollenzugriff anzeigen
<a name="roles-delete_prerequisites"></a>

Bevor Sie eine Rolle löschen, sollten Sie überprüfen, wann die Rolle zuletzt verwendet wurde. Sie können dazu die AWS-Managementkonsole AWS CLI, oder die AWS API verwenden. Sie sollten sich diese Informationen ansehen, weil Sie nicht jemandem den Zugriff entziehen wollen, der gerade die Rolle verwendet. 

Das Datum der letzten Aktivität der Rolle stimmt möglicherweise nicht mit dem letzten auf der Registerkarte **Letzter Zugriff** gemeldeten Datum überein. Auf der Registerkarte [**Letzter Zugriff**](access_policies_last-accessed-view-data.md) werden Aktivitäten nur für Services gemeldet, die laut der Berechtigungsrichtlinien der Rolle zulässig sind. Das Datum der letzten Aktivität der Rolle beinhaltet den letzten Versuch, auf einen Dienst in zuzugreifen AWS.

**Anmerkung**  
Der Nachverfolgungs-Zeitraum für die letzte Aktivität einer Rolle und die Letzter Zugriff-Daten beinhalten die letzten 400 Tage. Dieser Zeitraum kann kürzer sein, wenn Ihre Region diese Funktionen innerhalb des letzten Jahres zu unterstützen begonnen hat. Die Rolle könnte dann vor mehr als 400 Tagen verwendet worden sein. Weitere Informationen zum Nachverfolgungszeitraum finden Sie unter [Wo werden die AWS zuletzt aufgerufenen Informationen aufgezeichnet](access_policies_last-accessed.md#last-accessed_tracking-period).

**So zeigen Sie an, wann eine Rolle zuletzt verwendet wurde (Konsole):**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie im Navigationsbereich **Rollen**.

1. Suchen Sie die Zeile der Rolle, deren Aktivität Sie anzeigen möchten. Sie können das Suchfeld verwenden, um die Ergebnisse einzuschränken. Zeigen Sie die Spalte **Last activity (Letzte Aktivität)** an, um die Anzahl der Tage seit der letzten Verwendung der Rolle anzuzeigen. Wenn die Rolle nicht innerhalb des Verfolgungszeitraums verwendet wurde, wird in der Tabelle **None (Keine)**angezeigt. 

1. Wählen Sie den Namen der Rolle, um weitere Informationen anzuzeigen. Die Seite **Summary (Zusammenfassung)** der Rolle enthält auch **Last activity (Letzte Aktivität)**, mit der Anzeige des Datums, an dem die Rolle zuletzt verwendet wurde. Wenn die Rolle innerhalb der letzten 400 Tage nicht verwendet wurde, zeigt **Last activity (Letzte Aktivität)** **Not accessed in the tracking period (Kein Zugriff im nachverfolgungszeitraum)** an.

**So zeigen Sie an, wann eine Rolle zuletzt verwendet wurde (AWS CLI):**  
`[aws iam get-role](https://docs.aws.amazon.com/cli/latest/reference/iam/get-role.html)` - Führen Sie diesen Befehl aus, um Informationen über eine Rolle, einschließlich des `RoleLastUsed`-Objekts, zurückzugeben. Dieses Objekt enthält die `LastUsedDate` und die `Region`, in denen die Rolle zuletzt verwendet wurde. Wenn `RoleLastUsed` vorhanden ist, aber keinen Wert enthält, wurde die Rolle innerhalb des Verfolgungszeitraums nicht verwendet.

**Um zu sehen, wann eine Rolle zuletzt verwendet wurde (AWS API)**  
`[GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/GetRole.html)` - Rufen Sie diesen Vorgang auf, um Informationen über eine Rolle, einschließlich des `RoleLastUsed`-Objekts, zurückzugeben. Dieses Objekt enthält die `LastUsedDate` und die `Region`, in denen die Rolle zuletzt verwendet wurde. Wenn `RoleLastUsed` vorhanden ist, aber keinen Wert enthält, wurde die Rolle innerhalb des Verfolgungszeitraums nicht verwendet.

## Löschen einer serviceverknüpften Rolle
<a name="id_roles_manage_delete_slr"></a>

Die Methode, die Sie zum Löschen einer serviceverknüpften Rolle verwenden, hängt vom jeweiligen Service ab. In einigen Fällen müssen Sie die serviceverknüpfte Rolle nicht manuell löschen. Wenn Sie beispielsweise eine bestimmte Aktion (z. B. das Entfernen einer Ressource) im Service durchführen, löscht der Service die serviceverknüpfte Rolle eventuell für Sie. In anderen Fällen unterstützt der Service möglicherweise das manuelle Löschen einer serviceverknüpften Rolle mit der Servicekonsole, einer API oder der AWS CLI. 

Lesen Sie die Dokumentation zur *[serviceverknüpften Rolle](id_roles.md#iam-term-service-linked-role)* im verknüpften Service, um zu erfahren, wie Sie die Rolle löschen. Sie können die serviceverknüpften Rollen in Ihrem Konto anzeigen, indem Sie zur IAM-Seite **Roles** der Konsole wechseln. Serviceverknüpfte Rollen werden mit dem Hinweis **(Service-linked role)** in der Spalte **Trusted entities (Vertrauenswürdige Entitäten)** der Tabelle angezeigt. Ein Banner auf der Seite **Summary (Übersicht)** für die Rolle zeigt ebenfalls an, dass es sich um eine serviceverknüpfte Rolle handelt.

Wenn der Service keine Dokumentation zum Löschen der mit dem Service verknüpften Rolle enthält, können Sie die Rolle mithilfe der IAM-Konsole oder der API löschen. AWS CLI

## Löschen einer IAM-Rolle (Konsole)
<a name="roles-managingrole-deleting-console"></a>

Wenn Sie die AWS-Managementkonsole zum Löschen einer Rolle verwenden, trennt IAM automatisch die mit der Rolle verknüpften verwalteten Richtlinien. Außerdem werden alle eingebundenen Richtlinien gelöscht, die mit der Rolle verbunden sind. Außerdem werden alle Amazon-EC2-Instance-Profile gelöscht, die die Rolle enthalten. 

**Wichtig**  
In einigen Fällen kann eine Rolle mit einem Amazon EC2-Instance-Profil verbunden sein, und die Rolle und das Instance-Profil können denselben Namen haben. In diesem Fall können Sie die AWS-Managementkonsole zum Löschen der Rolle und des Instanzprofils verwenden. Diese Verknüpfung erfolgt automatisch für Rollen und Instance-Profile, die Sie in der Konsole erstellen. Wenn Sie die Rolle über Tools für Windows PowerShell oder die AWS API erstellt haben, haben die Rolle und das Instanzprofil möglicherweise unterschiedliche Namen. AWS CLI In diesem Fall können Sie die Konsole nicht zum Löschen verwenden. Stattdessen müssen Sie Tools für Windows oder AWS API verwenden PowerShell, um die Rolle zunächst aus dem Instanzprofil zu entfernen. AWS CLI Sie müssen die Rolle dann in einem separaten Schritt löschen.

**So löschen Sie eine Rolle (Konsole)**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie im Navigationsbereich **Roles (Rollen)**, und aktivieren Sie dann das Kontrollkästchen neben der Rolle, die Sie löschen möchten. 

1. Wählen Sie oben auf der Seite **Delete role (Rolle löschen)**.

1. Überprüfen Sie im Bestätigungsdialogfeld die Informationen, auf die zuletzt zugegriffen wurde. Darin wird angegeben, wann jede der ausgewählten Rollen zuletzt auf einen AWS Dienst zugegriffen hat. Auf diese Weise können Sie leichter bestätigen, ob die Rolle derzeit aktiv ist. Wenn Sie fortfahren möchten, geben Sie den Namen der Rolle in das Texteingabefeld ein und wählen Sie **Löschen**. Wenn Sie sich sicher sind, können Sie mit dem Löschen fortfahren, auch wenn die Informationen zum letzten Zugriff noch geladen werden.

**Anmerkung**  
Sie können die Konsole nicht verwenden, um ein Instance-Profil zu löschen, es sei denn, es hat denselben Namen wie die Rolle. Außerdem müssen Sie das Instance-Profil im Rahmen des Vorgangs zum Löschen einer Rolle, wie im zuvor genannten Vorgang beschrieben, löschen. Um ein Instanzprofil zu löschen, ohne auch die Rolle zu löschen, müssen Sie die AWS API AWS CLI oder verwenden. Weitere Informationen finden Sie in den folgenden Abschnitten.

## Erstellen einer IAM-Rolle (AWS CLI)
<a name="roles-managingrole-deleting-cli"></a>

Wenn Sie die verwenden, AWS CLI um eine Rolle zu löschen, müssen Sie zuerst die mit der Rolle verknüpften Inline-Richtlinien löschen. Sie müssen auch die mit der Rolle verknüpften verwalteten Richtlinien trennen. Wenn Sie das verbundene Instance-Profil, das die Rolle enthält, löschen möchten, müssen Sie es separat löschen.

**So löschen Sie eine Rolle (AWS CLI)**

1. Wenn Sie den Namen der Rolle, die Sie löschen möchten, nicht kennen, geben Sie den folgenden Befehl ein, um die Rollen in Ihrem Konto aufzulisten:

   ```
   aws iam list-roles
   ```

   Die Liste enthält den Amazon-Ressourcennamen (ARN) jeder Rolle. Verwenden Sie den Rollennamen, nicht den ARN, um sich auf Rollen mit den CLI-Befehlen zu beziehen. Wenn eine Rolle zum Beispiel folgenden ARN hat: `arn:aws:iam::123456789012:role/myrole`, verweisen Sie auf die Rolle als **myrole**.

1. Entfernen Sie die Rolle aus allen Instance-Profilen, mit denen die Rolle verbunden ist.

   1. Um alle Instance-Profile aufzulisten, denen die Rolle zugeordnet ist, geben Sie den folgenden Befehl ein:

      ```
      aws iam list-instance-profiles-for-role --role-name role-name
      ```

   1. Um die Rolle aus einem Instance-Profil zu entfernen, geben Sie den folgenden Befehl für jedes Instance-Profil ein:

      ```
      aws iam remove-role-from-instance-profile --instance-profile-name instance-profile-name --role-name role-name
      ```

1. Löschen Sie alle Richtlinien, die mit der Rolle verbunden sind.

   1. Um alle Inline-Richtlinien aufzulisten, die in der Rolle vorhanden sind, geben Sie den folgenden Befehl ein:

      ```
      aws iam list-role-policies --role-name role-name
      ```

   1. Um jede Inline-Richtlinie aus der Rolle zu löschen, geben Sie den folgenden Befehl für jede Richtlinie ein: 

      ```
      aws iam delete-role-policy --role-name role-name --policy-name policy-name
      ```

   1. Um alle verwalteten Richtlinien aufzulisten, die der Rolle angefügt sind, geben Sie den folgenden Befehl ein:

      ```
      aws iam list-attached-role-policies --role-name role-name
      ```

   1. Um jede verwaltete Richtlinie von der Rolle zu trennen, geben Sie den folgenden Befehl für jede Richtlinie ein: 

      ```
      aws iam detach-role-policy --role-name role-name --policy-arn policy-arn
      ```

1. Geben Sie den folgenden Befehl ein, um die Rolle zu löschen:

   ```
   aws iam delete-role --role-name role-name
   ```

1. Wenn Sie nicht vorhaben, die Instance-Profile, die der Rolle zugeordnet waren, wiederzuverwenden, geben Sie den folgenden Befehl ein, um sie zu löschen:

   ```
   aws iam delete-instance-profile --instance-profile-name instance-profile-name
   ```

## Löschen einer IAM-Rolle (AWS API)
<a name="roles-managingrole-deleting-api"></a>

Wenn Sie über die IAM-API eine Rolle löschen, müssen Sie zuerst die Inline-Richtlinien löschen, die der Rolle zugeordnet sind. Sie müssen auch die mit der Rolle verknüpften verwalteten Richtlinien trennen. Wenn Sie das verbundene Instance-Profil, das die Rolle enthält, löschen möchten, müssen Sie es separat löschen.

**Um eine Rolle (AWS API) zu löschen**

1. Rufen Sie auf, um alle Instanzprofile aufzulisten, denen eine Rolle zugeordnet ist [ListInstanceProfilesForRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html).

   Rufen Sie an, um die Rolle aus einem Instanzprofil zu entfernen [RemoveRoleFromInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html). Sie müssen den Rollennamen und den Instance-Profilnamen übergeben. 

   Wenn Sie ein Instanzprofil, das mit der Rolle verknüpft war, nicht wiederverwenden möchten, rufen Sie an, [DeleteInstanceProfile](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html)um es zu löschen.

1. Rufen Sie an, um alle Inline-Richtlinien für eine Rolle aufzulisten [ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html).

   Rufen Sie an, um Inline-Richtlinien zu löschen, die der Rolle zugeordnet sind [DeleteRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRolePolicy.html). Sie müssen den Rollennamen und den Inline-Richtliniennamen übergeben. 

1. Rufen Sie an, um alle verwalteten Richtlinien aufzulisten, die einer Rolle zugeordnet sind [ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html). 

   Rufen [DetachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DetachRolePolicy.html)Sie an, um verwaltete Richtlinien, die der Rolle zugeordnet sind, zu trennen. Sie müssen den Rollennamen und den ARN der verwalteten Richtlinie übergeben. 

1. Rufen Sie an [DeleteRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteRole.html), um die Rolle zu löschen.

## Ähnliche Informationen
<a name="roles-managingrole-deleting-related-info"></a>

Allgemeine Informationen zu Instance-Profilen finden Sie unter [Verwendung von Instance-Profilen](id_roles_use_switch-role-ec2_instance-profiles.md).

Allgemeine Informationen zu serviceverknüpften Rollen finden Sie unter [Erstellen einer serviceverknüpften Rolle](id_roles_create-service-linked-role.md).

# Methoden, um eine Rolle zu übernehmen
<a name="id_roles_manage-assume"></a>

Bevor ein Benutzer, Anwendungen oder Services eine von Ihnen erstellte Rolle verwenden können, müssen Sie [Berechtigungen zum Wechseln](id_roles_use_permissions-to-switch.md) zu dieser Rolle erteilen. Sie können jede Richtlinie verwenden, die Gruppen oder Benutzern angefügt ist, um die erforderlichen Berechtigungen zu gewähren. Nachdem die Berechtigungen erteilt wurden, kann der Benutzer eine Rolle über die AWS-Managementkonsole Tools für Windows PowerShell, die AWS Command Line Interface (AWS CLI) und die [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API übernehmen.

**Wichtig**  
Wenn Sie die Rolle programmgesteuert anstatt in der IAM-Konsole erstellen, haben Sie die Möglichkeit, einen `Path` mit bis zu 512 Zeichen und einen `RoleName` mit bis zu 64 Zeichen hinzuzufügen. Wenn Sie jedoch beabsichtigen, eine Rolle mit der Funktion „**Rolle wechseln**“ in der zu verwenden AWS-Managementkonsole, dann die Kombination `Path` und `RoleName` darf 64 Zeichen nicht überschreiten.

Die Methode zur Übernahme der Rolle bestimmt, wer die Rolle übernehmen kann und wie lange die Rollensitzung dauern kann. Bei der Verwendung von `AssumeRole*`-API-Vorgängen ist die von Ihnen angenommene IAM-Rolle die Ressource. Der Benutzer oder die Rolle, der/die `AssumeRole*`-API-Vorgänge aufruft, ist der Prinzipal.

In der folgenden Tabelle werden die Methoden zur Rollenübernahme verglichen.


|  Methode der Übernahme der Rolle |  **Wer die Rolle annehmen kann**  | **Methode zum Festlegen der Lebensdauer der Anmeldeinformationen** |  **Lebensdauer der Anmeldeinformationen (min \$1 max \$1 Standard)**  | 
| --- | --- | --- | --- | 
| AWS-Managementkonsole | Benutzer oder Rollen¹ (durch [Wechseln von Rollen](id_roles_use_switch-role-console.md)) | Maximale Sitzungsdauer auf der Seite -Rollen-Zusammenfassung | 15 Min. \$1 Maximale Sitzungsdauer² \$1 1 Std. | 
| [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html)-CLI- oder [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)-API-Operation |  Benutzer oder Rolle¹ | duration-seconds CLI- oder DurationSeconds API-Parameter | 15 Min. \$1 Maximale Sitzungsdauer² \$1 1 Std.  | 
| [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html)-CLI- oder [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)-API-Operation | Jeder Benutzer, der mit SAML authentifiziert wird | duration-seconds CLI- oder DurationSeconds API-Parameter | 15 Min. \$1 Maximale Sitzungsdauer² \$1 1 Std.  | 
| [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html)-CLI- oder [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)-API-Operation | Jeder Benutzer, der über einen OIDC-Anbieter authentifiziert wurde | duration-seconds CLI- oder DurationSeconds API-Parameter | 15 Min. \$1 Maximale Sitzungsdauer² \$1 1 Std.  | 
| [Konsolen-URL](id_roles_providers_enable-console-custom-url.md) erstellt mit AssumeRole  | Benutzer oder Rolle | SessionDuration HTML-Parameter in der URL | 15 Min. \$1 12 Std. \$1 1 Std.  | 
| [Konsolen-URL](id_roles_providers_enable-console-custom-url.md) erstellt mit AssumeRoleWithSAML  | Jeder Benutzer, der mit SAML authentifiziert wird | SessionDuration HTML-Parameter in der URL | 15 Min. \$1 12 Std. \$1 1 Std. | 
| [Konsolen-URL](id_roles_providers_enable-console-custom-url.md) erstellt mit AssumeRoleWithWebIdentity  | Jeder Benutzer, der über einen OIDC-Anbieter authentifiziert wurde | SessionDuration HTML-Parameter in der URL | 15 Min. \$1 12 Std. \$1 1 Std.  | 

¹ Das Verwenden der Anmeldeinformationen aus einer Rolle, um eine andere Rolle anzunehmen, wird als [Verketten von Rollen](id_roles.md#iam-term-role-chaining) bezeichnet. Wenn Sie das Verketten von Rollen verwenden, ist die Sitzungsdauer der Rolle auf eine Stunde begrenzt. Dies gilt für AWS-Managementkonsole Rollenwechsel AWS CLI und API-Operationen. Diese Einschränkung gilt nicht für die anfängliche Übernahme einer Rolle anhand von Benutzeranmeldedaten oder für Anwendungen, die auf EC2 Amazon-Instances mithilfe von Instance-Profilen ausgeführt werden.

Diese Einstellung kann einen Wert zwischen 1 Stunde und 12 Stunden haben. Weitere Informationen zur maximalen Sitzungsdauer finden Sie unter [IAM-Rollen-Verwaltung](id_roles_manage.md). Diese Einstellung bestimmt die maximale Sitzungsdauer, die Sie anfordern können, wenn Sie die Anmeldeinformationen einer Rolle erhalten. Wenn Sie beispielsweise die API-Operationen [AssumeRole\$1](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) verwenden, um eine Rolle anzunehmen, können Sie mithilfe des `DurationSeconds` Parameters eine Sitzungslänge angeben. Verwenden Sie diesen Parameter, um die Länge der Rollensitzung von 900 Sekunden (15 Minuten) bis zur maximalen Sitzungsdauer für die Rolle anzugeben. IAM-Benutzern wird die für die Rolle festgelegte maximale Sitzungsdauer oder die verbleibende Zeit in der Sitzung des Benutzers gewährt, je nachdem, welcher Wert geringer ist. Angenommen Sie, Sie eine maximale Dauer von 5 Stunden für eine Rolle festlegen. Ein IAM-Benutzer, der 10 Stunden lang bei der Konsole angemeldet wurde (ab dem Standardmaximum von 12), wechselt zur Rolle. Die verfügbare Rollensitzungsdauer beträgt 2 Stunden. Weitere Informationen zum Anzeigen des maximalen Werts für Ihre Rolle finden Sie unter [Aktualisieren der maximalen Sitzungsdauer für eine Rolle](id_roles_update-role-settings.md#id_roles_update-session-duration) weiter unten auf dieser Seite.

**Hinweise**  
Die Einstellung für die maximale Sitzungsdauer beschränkt keine Sitzungen, die von AWS -Services übernommen werden.
Die Anmeldeinformationen für Amazon EC2 IAM-Rollen unterliegen nicht der in der Rolle konfigurierten maximalen Sitzungsdauer.
Damit Benutzer die aktuelle Rolle innerhalb einer Rollensitzung wieder übernehmen können, geben Sie den Rollen-ARN oder AWS-Konto ARN als Principal in der Rollenvertrauensrichtlinie an. AWS-Services die Rechenressourcen wie Amazon EC2, Amazon ECS, Amazon EKS und Lambda bereitstellen, stellen temporäre Anmeldeinformationen bereit und aktualisieren diese Anmeldeinformationen automatisch. Dadurch wird sichergestellt, dass Sie immer über gültige Anmeldeinformationen verfügen. Für diese Dienste ist es nicht erforderlich, die aktuelle Rolle erneut anzunehmen, um temporäre Anmeldeinformationen zu erhalten. Wenn Sie jedoch beabsichtigen, [Sitzungs-Tags](id_session-tags.md) oder eine [Sitzungsrichtlinie](access_policies.md#policies_session) zu übergeben, müssen Sie die aktuelle Rolle erneut annehmen. Informationen zum Ändern einer Rollenvertrauensrichtlinie zum Hinzufügen der Hauptrollen ARN oder AWS-Konto ARN finden Sie unter[Rollenvertrauensrichtlinie aktualisieren](id_roles_update-role-trust-policy.md).

**Topics**
+ [Von einem Benutzer zu einer IAM-Rolle wechseln (Konsole)](id_roles_use_switch-role-console.md)
+ [Zu einer IAM-Rolle wechseln (AWS CLI)](id_roles_use_switch-role-cli.md)
+ [Zu einer IAM-Rolle wechseln (Tools für Windows PowerShell)](id_roles_use_switch-role-twp.md)
+ [Zu einer IAM-Rolle (AWS API) wechseln](id_roles_use_switch-role-api.md)
+ [Verwendung einer IAM-Rolle zur Gewährung von Berechtigungen für Anwendungen, die in Amazon-EC2-Instances ausgeführt werden](id_roles_use_switch-role-ec2.md)
+ [Verwendung von Instance-Profilen](id_roles_use_switch-role-ec2_instance-profiles.md)

# Von einem Benutzer zu einer IAM-Rolle wechseln (Konsole)
<a name="id_roles_use_switch-role-console"></a>

Sie können die Rolle wechseln, wenn Sie sich als IAM-Benutzer, als Benutzer im IAM Identity Center, als SAML-verbundene Rolle oder als Web-Identitätsverbundene Rolle anmelden. Eine *Rolle* gibt eine Reihe von Berechtigungen an, mit denen Sie auf die benötigten AWS Ressourcen zugreifen können. Sie melden sich jedoch nicht bei einer Rolle an, können aber, sobald Sie als IAM-Benutzer angemeldet sind, zu einer IAM-Rolle wechseln. Dadurch werden Ihre ursprünglichen Benutzerberechtigungen vorübergehend zurückgestellt und Sie erhalten stattdessen die der Rolle zugewiesenen Berechtigungen. Die Rolle kann sich in Ihrem eigenen Konto oder jedem anderen AWS-Konto befinden. Weitere Informationen zu Rollen, ihren Vorteilen sowie zu ihrer Erstellung finden Sie unter [IAM-Rollen](id_roles.md) und [Erstellung einer IAM-Rolle](id_roles_create.md).

Die Berechtigungen Ihres Benutzers und aller Rollen, zu denen Sie wechseln, sind nicht kumulativ. Es ist nur jeweils ein Satz von Berechtigungen aktiv. Wenn Sie zu einer Rolle wechseln, geben Sie Ihre Benutzerberechtigungen temporär auf und arbeiten mit den Berechtigungen, die der Rolle zugeordnet sind. Wenn Sie die Rolle verlassen, werden Ihre Benutzerberechtigungen automatisch wiederhergestellt.

Wenn Sie in der die Rollen wechseln AWS-Managementkonsole, verwendet die Konsole immer Ihre ursprünglichen Anmeldeinformationen, um den Switch zu autorisieren. Wenn Sie beispielsweise zu Rolle A wechseln, verwendet IAM Ihre ursprünglichen Anmeldeinformationen, um zu bestimmen, ob Sie Rolle A übernehmen dürfen. Wenn Sie dann zu RoleB wechseln, *während Sie RoleA verwenden, verwendet AWS immer noch Ihre **ursprünglichen** Anmeldeinformationen, um den Wechsel zu autorisieren, nicht die Anmeldeinformationen für RoleA*.

**Anmerkung**  
Wenn Sie sich als Benutzer im IAM Identity Center, mit einer SAML-Verbundrolle oder mit einer Web-Identitäts-Verbundrolle anmelden, übernehmen Sie beim Starten Ihrer Sitzung eine IAM-Rolle. Wenn sich beispielsweise ein Benutzer in IAM Identity Center beim AWS Zugriffsportal anmeldet, muss er einen Berechtigungssatz auswählen, der einer Rolle entspricht, bevor er auf Ressourcen zugreifen kann. AWS 

## Rollensitzungen
<a name="id_roles_iam_user-switch-role-sessions"></a>

Wenn Sie die Rollen wechseln, dauert Ihre AWS-Managementkonsole Sitzung standardmäßig 1 Stunde. IAM-Benutzer-Sitzungen dauern standardmäßig 12 Stunden. Für andere Benutzer sind möglicherweise andere Sitzungsdauern definiert. Wenn Sie in der Konsole die Rollen wechseln, wird Ihnen die für Ihre Rolle maximale Sitzungsdauer oder die verbleibende Zeit Ihrer Benutzersitzung zugewiesen (je nachdem, welche Dauer kürzer ist). Eine Verlängerung der Sitzungsdauer ist durch die Übernahme einer Rolle nicht möglich.

Nehmen Sie beispielsweise an, dass eine maximale Sitzungsdauer von 10 Stunden für eine Rolle festgelegt ist. Sie waren 8 Stunden lang bei der Konsole angemeldet, als Sie sich entschieden haben, zur Rolle zu wechseln. Es verbleiben noch 4 Stunden in Ihrer Benutzersitzung. Daher beträgt die zulässige Rollensitzungsdauer 4 Stunden, nicht die maximale Sitzungsdauer von 10 Stunden. Die folgende Tabelle zeigt, wie die Sitzungsdauer für einen IAM-Benutzer beim Wechseln von Rollen in der Konsole ermittelt wird.


| Die verbleibende IAM-Benutzersitzung ist... | Rollensitzungsdauer beträgt… | 
| --- | --- | 
| Maximale Sitzungsdauer unter Rolle | Verbleibende Zeit in Benutzersitzung | 
| Maximale Sitzungsdauer größer als Rolle | Maximale Sitzungsdauer | 
| Gleich der maximalen Sitzungsdauer der Rolle | Maximaler Wert für die Sitzungsdauer (ungefähr) | 

Das Verwenden der Anmeldeinformationen aus einer Rolle, um eine andere Rolle anzunehmen, wird als [Verketten von Rollen](id_roles.md#iam-term-role-chaining) bezeichnet. Wenn Sie das Verketten von Rollen verwenden, ist die Sitzungsdauer auf eine Stunde begrenzt, unabhängig von der Einstellung für die maximale Sitzungsdauer, die für einzelne Rollen konfiguriert wurde. Dies gilt für AWS-Managementkonsole Rollenwechsel AWS CLI und API-Operationen.

**Anmerkung**  
Einige AWS Servicekonsolen können Ihre Rollensitzung nach Ablauf automatisch verlängern, ohne dass Sie etwas unternehmen müssen. Einige werden Sie möglicherweise aufgefordert, Ihre Browserseite neu zu laden, um Ihre Sitzung erneut zu authentifizieren.

## Überlegungen
<a name="id_roles_iam_user-switch-role-considerations"></a>
+ Sie können die Rollen nicht wechseln, wenn Sie sich als anmelden. Root-Benutzer des AWS-Kontos
+ Benutzern muss die Berechtigung zum Rollenwechsel durch die Richtlinie gewährt werden. Detaillierte Anweisungen finden Sie unter [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md).
+ Sie können die Rollen nicht AWS-Managementkonsole zu einer Rolle wechseln, für die ein [ExternalId](id_roles_common-scenarios_third-party.md#id_roles_third-party_external-id)Wert erforderlich ist. Sie können nur zu einer solchen Rolle wechseln, indem Sie die [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)-API aufrufen, die den `ExternalId`-Parameter unterstützt.

## So wechseln Sie zu einer Rolle
<a name="id_roles_iam_user-switch-role-console-procedure"></a>

1. Folgen Sie dem Anmeldeverfahren, das Ihrem Benutzertyp entspricht, wie im Abschnitt [Anmelden an der AWS-Managementkonsole](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) im *AWS-Anmeldung -Benutzerhandbuch* beschrieben.

1. Wählen Sie in der AWS-Managementkonsole Navigationsleiste oben rechts Ihren Benutzernamen aus. Es sieht normalerweise so aus: ***username*@ *account\$1ID\$1number\$1or\$1alias***.

1. Wählen Sie eine der folgenden Methoden aus, um Rollen zu wechseln:
   + Wählen Sie **Rolle wechseln** aus.
   + Wenn Sie sich für die Unterstützung mehrerer Sitzungen entschieden haben, wählen Sie **Sitzung hinzufügen** und dann **Rolle wechseln** aus.
**Anmerkung**  
Sie können sich mit bis zu fünf verschiedenen Identitäten gleichzeitig in einem einzigen Webbrowser in der AWS-Managementkonsole anmelden. Details finden Sie im *Handbuch zu den ersten Schritten mit der AWS-Managementkonsole * unter [Anmeldung bei mehreren Konten](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/multisession.html).

1. Geben Sie auf der Seite **Switch Role (Rolle wechseln)** die Konto-ID-Nummer oder den Kontoalias sowie den Namen der Rolle ein, die Sie von Ihrem Administrator erhalten haben.
**Anmerkung**  
Wenn der Administrator die Rolle mit einem Pfad erstellt hat, z. B. `division_abc/subdivision_efg/roleToDoX`, müssen Sie den vollständigen Pfad sowie den Namen im Feld **Role (Rolle)** eingeben. Wenn Sie nur den Rollennamen eingeben oder der kombinierte `Path` und `RoleName` 64 Zeichen überschreiten, schlägt der Wechsel der Rolle fehl. Diese Begrenzung wird durch die Browser-Cookies vorgegeben, in denen der Rollenname gespeichert wird. Wenn dies der Fall ist, wenden Sie sich an Ihren Administrator und bitten Sie Ihn, die Größe des Pfads und Rollennamens zu verringern.

1. (Optional) Sie können einen Anzeigenamen eingeben und eine Anzeigefarbe auswählen, die die Rolle in der Navigationsleiste der Konsole hervorhebt.
   + Geben Sie unter **Anzeigename** den Text ein, der anstelle Ihres Benutzernamens in der Navigationsleiste angezeigt werden soll, wenn diese Rolle aktiv ist. Es wird ein Name basierend auf den Konto- und Rolleninformationen vorgeschlagen. Sie können jedoch einen beliebigen Namen wählen. 
   + Wählen Sie bei **Anzeigefarbe** eine Farbe aus, um den Anzeigenamen hervorzuheben.

   Der Name und die Farbe helfen Ihnen dabei zu erkennen, dass die Rolle aktiv ist und Sie dadurch möglicherweise über andere Berechtigungen verfügen. Sie können beispielsweise für eine Rolle, die Ihnen Zugriff auf die Testumgebung gewährt, den **Display Name (Anzeigename)** **Test** und die **Color (Farbe)** grün auswählen. Für die Rolle, die Ihnen Zugriff auf die Produktionsumgebung gewährt, können Sie den **Display Name (Anzeigename)** **Production** und die **Color (Farbe)** rot auswählen.

1. Wählen Sie **Switch Role**. Ihr Benutzername auf der Navigationsleiste wird durch den Anzeigenamen in der gewählten Farbe ersetzt und Sie können die durch die Rolle gewährten Berechtigungen nutzen.

1. Nachdem Sie die Aufgaben abgeschlossen haben, die die IAM-Rolle erfordern, können Sie zu Ihrer ursprünglichen Sitzung zurückkehren. Dadurch werden die durch die Rolle bereitgestellten zusätzlichen Berechtigungen entfernt und Sie erhalten wieder Ihre Standardberechtigungen.

   1. Klicken Sie in der IAM-Konsole oben rechts in der Navigationsleiste auf **Display Name (Anzeigename)** der Rolle.

   1. Wählen Sie **Zurückwechseln** aus.

      Nehmen wir zum Beispiel an, dass Sie mit der Kontonummer `123456789012` und dem Benutzernamen `Richard` angemeldet sind. Nach der Verwendung der `admin-role`-Rolle können Sie die Verwendung der Rolle beenden und zu Ihren ursprünglichen Berechtigungen zurückkehren. Um die Verwendung der Rolle zu beenden, wählen Sie **Admin-Rolle @ 123456789012** und dann **Zurückwechseln** aus.  
![\[Grafik zum Auffinden der Funktion „Zurückwechseln“, um die Verwendung einer IAM-Rolle zu beenden und zum ursprünglichen Benutzer zurückzukehren.\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/role-stop-using.png)

**Tipp**  
Die zuletzt verwendeten Rollen werden im Menü angezeigt. Wenn Sie das nächste Mal zu einer dieser Rollen wechseln möchten, können Sie einfach die gewünschte Rolle auswählen. Sie müssen die Konto- und Rolleninformationen nur dann manuell eingeben, wenn die Rolle nicht im Menü angezeigt wird.

## Weitere Ressourcen
<a name="id_roles_use_switch-role-console_additional_resources"></a>
+ [Gewähren von Berechtigungen an einen Benutzer zum Rollenwechsel](id_roles_use_permissions-to-switch.md)
+ [Erteilen Sie einem Benutzer die Erlaubnis, eine Rolle an einen AWS Dienst zu übergeben](id_roles_use_passrole.md)
+ [Erstellen einer Rolle zum Erteilen von Berechtigungen an einen IAM-Benutzer](id_roles_create_for-user.md)
+ [Erstellen Sie eine Rolle, um Berechtigungen an einen AWS Dienst zu delegieren](id_roles_create_for-service.md)
+ [Fehlerbehebung bei IAM-Rollen](troubleshoot_roles.md)

# Zu einer IAM-Rolle wechseln (AWS CLI)
<a name="id_roles_use_switch-role-cli"></a>

Eine *Rolle* legt eine Gruppe von Berechtigungen fest, die Sie für den Zugriff auf AWS -Ressourcen, die Sie benötigen, verwenden können. In dieser Hinsicht ist sie mit einem [IAM-Benutzer AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) vergleichbar. Wenn Sie sich als Benutzer anmelden, erhalten Sie einen bestimmten Satz von Berechtigungen. Sie melden sich jedoch nicht bei einer Rolle an. Wenn Sie sich aber als Benutzer angemeldet haben, können Sie zu einer Rolle wechseln. Dadurch werden Ihre ursprünglichen Benutzerberechtigungen vorübergehend zurückgestellt und Sie erhalten stattdessen die der Rolle zugewiesenen Berechtigungen. Die Rolle kann sich in Ihrem eigenen Konto oder jedem anderen AWS-Konto befinden. Weitere Informationen zu Rollen, ihren Vorteilen sowie zu ihrer Erstellung und Konfiguration finden Sie unter [IAM-Rollen](id_roles.md)und [Erstellung einer IAM-Rolle](id_roles_create.md). 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).

**Wichtig**  
Die Berechtigungen Ihres IAM-Benutzers und alle Rollen, die Sie annehmen, können nicht kumuliert werden. Es ist nur jeweils ein Satz von Berechtigungen aktiv. Wenn Sie eine Rolle annehmen, geben Sie Ihre vorherigen Benutzer- oder Rollenberechtigungen temporär auf und arbeiten mit den Berechtigungen, die der Rolle zugeordnet sind. Wenn Sie die Rolle verlassen, werden Ihre Benutzerberechtigungen automatisch wiederhergestellt.

Sie können eine Rolle verwenden, um einen AWS CLI Befehl auszuführen, wenn Sie als IAM-Benutzer angemeldet sind. Sie können eine Rolle auch verwenden, um einen AWS CLI Befehl auszuführen, wenn Sie als [extern authentifizierter Benutzer](id_roles_providers.md) ([SAML](id_roles_providers_saml.md) oder [OIDC](id_roles_providers_oidc.md)) angemeldet sind, der bereits eine Rolle verwendet. Darüber hinaus können Sie eine Rolle für die Ausführung eines AWS CLI -Befehls aus einer Amazon EC2-Instance verwenden, die einer Rolle über ihr Instance-Profil zugeordnet ist. Sie können keine Rolle anwenden, wenn Sie sich als Root-Benutzer des AWS-Kontos anmelden.

[**Verketten von Rollen**](id_roles.md#iam-term-role-chaining) – Sie können auch das Verketten von Rollen verwenden, was bedeutet, Berechtigungen einer Rolle für den Zugriff auf eine zweite Rolle zu verwenden.

Standardmäßig ist Ihre Rollensitzung eine Stunde gültig. Wenn Sie diese Rolle mithilfe der `assume-role*`-CLI-Operationen annehmen, können Sie einen Wert für den `duration-seconds`-Parameter angeben. Dieser Wert kann zwischen 900 Sekunden (15 Minuten) und der maximalen Sitzungsdauer für die Rolle liegen. Wenn Sie in der Konsole die Rollen wechseln, ist Ihre Sitzungsdauer auf maximal eine Stunde begrenzt. Weitere Informationen dazu, wie Sie den maximalen Wert für Ihre Rolle anzeigen, 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 Verkettung von Rollen verwenden, ist Ihre Sitzungsdauer auf die maximale Dauer von einer Stunde begrenzt. Wenn Sie den `duration-seconds`-Parameter verwenden, um einen Wert größer als eine Stunde anzugeben, schlägt die Operation fehl.

## Beispielszenario: Wechseln zu einer Produktionsrolle
<a name="switch-role-cli-scenario-prod-env"></a>

Stellen Sie sich vor, Sie sind ein IAM-Benutzer und arbeiten in der der Entwicklungsumgebung. In diesem Szenario müssen Sie gelegentlich mit der Produktionsumgebung an der Befehlszeile mit der [AWS CLI](https://aws.amazon.com/cli/) arbeiten. Sie haben bereits einen Zugriffsschlüsselsatz, die Ihnen zur Verfügung steht. Dies kann das Zugriffsschlüsselpaar sein, das dem IAM-Standardbenutzer zugewiesen ist. Wenn Sie dagegen als SAML- oder OICD-Verbundprinzipal angemeldet sind, kann es sich um das Zugriffsschlüsselpaar für die Rolle handeln, die Ihnen ursprünglich zugewiesen wurde. Wenn Ihre aktuellen Berechtigungen Ihnen die Möglichkeit geben, eine bestimmte IAM-Rolle anzunehmen, können Sie diese Rolle in einem „Profil“ in den Konfigurationsdateien identifizieren. AWS CLI Dieser Befehl wird dann mit den Berechtigungen der angegebenen IAM-Rolle, nicht mit der ursprünglichen Identität ausgeführt. Beachten Sie, dass Sie die neue Rolle verwenden, wenn Sie dieses Profil in einem AWS CLI Befehl angeben. In dieser Situation können Sie nicht gleichzeitig die ursprünglichen Berechtigungen im Entwicklungskonto nutzen. Der Grund besteht darin, dass zu einem bestimmten Zeitpunkt nur jeweils ein Satz Berechtigungen wirksam sein kann.

**Anmerkung**  
Aus Sicherheitsgründen können Administratoren anhand von [AWS CloudTrail Protokollen herausfinden](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds), wer eine Aktion in ausgeführt hat AWS. Ihr Administrator erfordert möglicherweise, dass Sie einen bestimmten Wert für den Sitzungsnamen angeben, wenn Sie die Rolle übernehmen. Weitere Informationen erhalten Sie unter [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) und [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

**So wechseln Sie zu einer Produktionsrolle (AWS CLI)**

1. <a name="step-configure-default"></a>Wenn Sie das noch nie verwendet haben AWS CLI, müssen Sie zuerst Ihr Standard-CLI-Profil konfigurieren. Öffnen Sie eine Befehlszeile und richten Sie Ihre AWS CLI Installation so ein, dass sie den Zugriffsschlüssel Ihres IAM-Benutzers oder Ihrer Verbundrolle verwendet. Weitere Informationen finden Sie unter [Konfigurieren der AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-quick-configuration) im *AWS Command Line Interface -Leitfaden*.

   Konfigurieren Sie die [ mit dem Befehl ](https://docs.aws.amazon.com/cli/latest/reference/configure/) wie folgt:

   ```
   aws configure
   ```

   Wenn Sie dazu aufgefordert werden, geben Sie die folgenden Informationen an:

   ```
   AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
   AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   Default region name [None]: us-east-2
   Default output format [None]: json
   ```

1. Erstellen Sie ein neues Profil für die Rolle in der Datei `.aws/config` in Unix oder Linux oder in der Datei `C:\Users\USERNAME\.aws\config` in Windows. Im folgenden Beispiel wird ein Profil mit dem Namen `prodaccess` erstellt, das zur Rolle `ProductionAccessRole` im `123456789012`-Konto wechselt. Der ARN der Rolle wird Ihnen vom Kontoadministrator, der die Rolle erstellt hat, mitgeteilt. Wenn dieses Profil aufgerufen wird, AWS CLI verwendet es die Anmeldeinformationen von, um Anmeldeinformationen für die `source_profile` Rolle anzufordern. Daher muss die Identität, die als `source_profile` referenziert ist, über `sts:AssumeRole`-Berechtigungen für die Rolle verfügen, die in `role_arn` angegeben ist.

   ```
   [profile prodaccess]
       role_arn = arn:aws:iam::123456789012:role/ProductionAccessRole
       source_profile = default
   ```

1. Nachdem Sie das neue Profil erstellt haben, wird jeder AWS CLI Befehl, der den Parameter angibt, unter den Berechtigungen `--profile prodaccess` ausgeführt, die der IAM-Rolle zugewiesen sind, und nicht unter den Berechtigungen `ProductionAccessRole` des Standardbenutzers.

   ```
   aws iam list-users --profile prodaccess
   ```

   Dieser Befehl funktioniert, wenn die Berechtigungen, die `ProductionAccessRole` zugeordnet sind, das Auflisten der Benutzer im aktuellen AWS -Konto ermöglichen.

1. Um zu den Berechtigungen zurückzukehren, die von Ihren ursprünglichen Anmeldeinformationen erteilt wurden, führen Sie Befehle ohne den `--profile`-Parameter. Das AWS CLI verwendet wieder die Anmeldeinformationen in Ihrem Standardprofil, in dem Sie es konfiguriert haben. [Step 1](#step-configure-default)

Weitere Informationen hierzu finden Sie unter [Assuming a Role](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html) im *AWS Command Line Interface Leitfaden*.

## Beispielszenario: Einer Instance-Profilrolle erlauben, zu einer Rolle in einem anderen Konto zu wechseln
<a name="switch-role-cli-scenario-ec2-instance"></a>

Stellen Sie sich vor AWS-Konten, Sie verwenden zwei und möchten einer Anwendung, die auf einer Amazon EC2 EC2-Instance ausgeführt wird, erlauben, [AWS CLI](https://aws.amazon.com/cli/)Befehle in beiden Konten auszuführen. Gehen Sie davon aus, dass die EC2-Instance im Konto `111111111111` vorhanden ist. Diese Instance enthält die `abcd`-Instance-Profilrolle, die der Anwendung erlaubt, schreibgeschützte Amazon S3-Aufgaben für den `amzn-s3-demo-bucket1`-Bucket innerhalb desselben `111111111111` Kontos auszuführen. Die Anwendung muss aber auch berechtigt sein, die kontoübergreifende `efgh`-Rolle zu übernehmen, um Aufgaben im Konto `222222222222` auszuführen. Dazu muss der EC2-Instance-Profilrolle `abcd` die folgende Berechtigungsrichtlinie zugeordnet sein.

***Konto 111111111111 `abcd` Rollen-Berechtigungsrichtlinie***

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket1/*",
                "arn:aws:s3:::amzn-s3-demo-bucket1"
            ]
        },
        {
            "Sid": "AllowIPToAssumeCrossAccountRole",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::222222222222:role/efgh"
        }
    ]
}
```

------

Gehen Sie davon aus, dass die kontoübergreifende `efgh`-Rolle die Ausführung schreibgeschützter Amazon S3-Aufgaben für den `amzn-s3-demo-bucket2`-Bucket im selben `222222222222`-Konto zulässt. Dazu muss der kontoübergreifenden `efgh`-Rolle die folgende Berechtigungsrichtlinie zugeordnet sein:

***Konto 222222222222 `efgh` Rollen-Berechtigungsrichtlinie***

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket2/*",
                "arn:aws:s3:::amzn-s3-demo-bucket2"
            ]
        }
    ]
}
```

------

Die `efgh`-Rolle muss der `abcd`-Instance-Profilrolle die Übernahme erlauben. Dazu benötigt die `efgh`-Rolle die folgende Vertrauensrichtlinie:

***Konto 222222222222 `efgh` Rollen-Berechtigungsrichtlinie***

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "efghTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"}
        }
    ]
}
```

------

Um dann AWS CLI Befehle im Konto auszuführen`222222222222`, müssen Sie die CLI-Konfigurationsdatei aktualisieren. Identifizieren Sie die `efgh`-Rolle als "Profil" und die `abcd`-EC2-Instance-Profilrolle als "Quelle der Anmeldeinformationen“ in der AWS CLI -Konfigurationsdatei. Dann werden Ihre CLI-Befehle mit den Berechtigungen der `efgh`-Rolle und nicht mit denen der ursprünglichen `abcd`-Rolle ausgeführt.

**Anmerkung**  
Aus Sicherheitsgründen können Sie AWS CloudTrail damit die Verwendung von Rollen im Konto überprüfen. Um in CloudTrail Protokollen zwischen Rollensitzungen zu unterscheiden, wenn eine Rolle von verschiedenen Prinzipalen verwendet wird, können Sie den Namen der Rollensitzung verwenden. Wenn der eine Rolle im Namen eines Benutzers AWS CLI übernimmt, wie in diesem Thema beschrieben, wird automatisch ein Rollensitzungsname als `AWS-CLI-session-nnnnnnnn` erstellt. Hier *nnnnnnnn* ist eine Ganzzahl, die die Zeit in [Unix-Epochenzeit](http://wikipedia.org/wiki/Unix_time) darstellt (die Anzahl der Sekunden seit Mitternacht UTC am 1. Januar 1970). Weitere Informationen finden Sie unter [CloudTrail Event Reference](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/eventreference.html) im *AWS CloudTrail Benutzerhandbuch*.

**So lassen Sie zu, dass eine EC2-Instance-Profilrolle zu einer kontoübergreifenden Rolle wechselt (AWS CLI)**

1. Sie müssen kein Standard-CLI-Profil konfigurieren. Stattdessen können Sie Anmeldeinformationen aus den Metadaten des EC2-Instance-Profils laden. Erstellen Sie ein neues Profil für die Rolle in der `.aws/config`-Datei. Das folgende Beispiel erstellt ein `instancecrossaccount`-Profil, das zur `efgh`-Rolle im `222222222222`-Konto wechselt. Wenn dieses Profil aufgerufen wird, verwendet die AWS CLI die Anmeldeinformationen aus den Metadaten des EC2-Instance-Profils, um Anmeldeinformationen für die Rolle anzufordern. Deshalb muss das EC2-Instance-Profil über die `sts:AssumeRole`-Berechtigungen für die Rolle verfügen, die in `role_arn` angegeben ist.

   ```
   [profile instancecrossaccount]
   role_arn = arn:aws:iam::222222222222:role/efgh
   credential_source = Ec2InstanceMetadata
   ```

1. Nachdem Sie das neue Profil erstellt haben, wird jeder AWS CLI Befehl, der den Parameter angibt, unter den Berechtigungen `--profile instancecrossaccount` ausgeführt, die der `efgh` Rolle im Konto zugewiesen sind`222222222222`.

   ```
   aws s3 ls amzn-s3-demo-bucket2 --profile instancecrossaccount
   ```

   Dieser Befehl funktioniert, wenn die Berechtigungen, die zur `efgh`-Rolle zugewiesen sind, die Auflistung der Benutzer im aktuellen AWS-Konto zulässt.

1. Zum Zurückkehren zu den ursprünglichen EC2-Instance-Profilberechtigungen im Konto `111111111111` führen Sie die CLI-Befehle ohne den Parameter `--profile`.

Weitere Informationen hierzu finden Sie unter [Assuming a Role](https://docs.aws.amazon.com/cli/latest/userguide/cli-roles.html) im *AWS Command Line Interface Leitfaden*.

# Zu einer IAM-Rolle wechseln (Tools für Windows PowerShell)
<a name="id_roles_use_switch-role-twp"></a>

Eine *Rolle* legt eine Gruppe von Berechtigungen fest, die Sie für den Zugriff auf AWS -Ressourcen, die Sie benötigen, verwenden können. In dieser Hinsicht ist sie mit einem [IAM-Benutzer AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) vergleichbar. Wenn Sie sich als Benutzer anmelden, erhalten Sie einen bestimmten Satz von Berechtigungen. Sie melden sich nicht bei einer Rolle an, aber sobald Sie angemeldet sind, können Sie zu einer Rolle wechseln. Dadurch werden Ihre ursprünglichen Benutzerberechtigungen vorübergehend zurückgestellt und Sie erhalten stattdessen die der Rolle zugewiesenen Berechtigungen. Die Rolle kann sich in Ihrem eigenen Konto oder jedem anderen AWS-Konto befinden. Weitere Informationen zu Rollen, ihren Vorteilen sowie zu ihrer Erstellung und Konfiguration finden Sie unter [IAM-Rollen](id_roles.md)und [Erstellung einer IAM-Rolle](id_roles_create.md).

**Wichtig**  
Die Berechtigungen Ihres IAM-Benutzers und alle Rollen, zu denen Sie wechseln, können nicht kumuliert werden. Es ist nur jeweils ein Satz von Berechtigungen aktiv. Wenn Sie zu einer Rolle wechseln, geben Sie Ihre Benutzerberechtigungen temporär auf und arbeiten mit den Berechtigungen, die der Rolle zugeordnet sind. Wenn Sie die Rolle verlassen, werden Ihre Benutzerberechtigungen automatisch wiederhergestellt.

In diesem Abschnitt wird beschrieben, wie Sie Rollen wechseln, wenn Sie mit den AWS Tools for Windows PowerShell in der Befehlszeile arbeiten.

Stellen Sie sich vor, Sie haben ein Konto in der Entwicklungsumgebung und müssen gelegentlich über die Befehlszeile mit den [Tools für Windows PowerShell](https://aws.amazon.com/powershell/) mit der Produktionsumgebung arbeiten. Es steht Ihnen bereits ein Satz an Zugriffsschlüsseln zur Verfügung. Dies kann ein Zugriffsschlüsselpaar sein, das dem IAM-Standardbenutzer zugewiesen ist. Wenn Sie dagegen als SAML- oder OICD-Verbundprinzipal angemeldet sind, kann es sich um das Zugriffsschlüsselpaar für die Rolle handeln, die Ihnen ursprünglich zugewiesen wurde. Sie können diese Anmeldeinformationen verwenden, um das `Use-STSRole`-Cmdlet auszuführen, das den ARN einer neuen Rolle als Parameter übergibt. Der Befehl gibt temporäre Sicherheitsanmeldeinformationen für die angeforderte Rolle zurück. Sie können diese Anmeldeinformationen dann in nachfolgenden PowerShell Befehlen mit den Berechtigungen der Rolle für den Zugriff auf Ressourcen in der Produktion verwenden. Solange Sie die Rolle verwenden, können Sie Ihre Benutzerberechtigungen im Entwicklungskonto nicht nutzen, da immer nur jeweils ein Satz an Berechtigungen wirksam ist.

**Anmerkung**  
Aus Sicherheitsgründen können Administratoren anhand von [AWS CloudTrail Protokollen herausfinden](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds), wer eine Aktion in ausgeführt hat AWS. Ihr Administrator erfordert möglicherweise, dass Sie einen bestimmten Wert für den Sitzungsnamen angeben, wenn Sie die Rolle übernehmen. Weitere Informationen erhalten Sie unter [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) und [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

Beachten Sie, dass alle Zugriffsschlüssel und Token nur Beispiele sind und nicht wie hier dargestellt verwendet werden können. Ersetzen Sie sie mit den entsprechenden Werten aus Ihrer Live-Umgebung.

**Um zu einer Rolle zu wechseln (Tools für Windows PowerShell)**

1. Öffnen Sie eine PowerShell Befehlszeile und konfigurieren Sie das Standardprofil so, dass es den Zugriffsschlüssel Ihres aktuellen IAM-Benutzers oder Ihrer Verbundrolle verwendet. Wenn Sie die Tools für Windows bereits verwendet haben PowerShell, ist dies wahrscheinlich bereits geschehen. Beachten Sie, dass Sie Rollen nur dann wechseln können, wenn Sie als IAM-Benutzer und nicht als der Root-Benutzer des AWS-Kontos angemeldet sind.

   ```
   PS C:\> Set-AWSCredentials -AccessKey AKIAIOSFODNN7EXAMPLE -SecretKey wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY -StoreAs MyMainUserProfile
   PS C:\> Initialize-AWSDefaults -ProfileName MyMainUserProfile -Region us-east-2
   ```

   Weitere Informationen finden Sie im *AWS -Tools für PowerShell Benutzerhandbuch* [unter Verwenden von AWS Anmeldeinformationen](https://docs.aws.amazon.com/powershell/latest/userguide/specifying-your-aws-credentials.html).

1. Um die Anmeldeinformationen für die neue Rolle abzurufen, führen Sie den folgenden Befehl aus, um zur `RoleName`-Rolle im Konto 123456789012 zu wechseln. Der ARN der Rolle wird Ihnen vom Kontoadministrator, der die Rolle erstellt hat, mitgeteilt. Der Befehl erfordert, dass Sie außerdem einen Sitzungsnamen angeben. Sie können hierfür einen beliebigen Text wählen. Der folgende Befehl fordert die Anmeldeinformationen an und erfasst dann das `Credentials`-Eigenschaftsobjekt vom zurückgegebenen Ergebnisobjekt und speichert es in der `$Creds`-Variablen.

   ```
   PS C:\> $Creds = (Use-STSRole -RoleArn "arn:aws:iam::123456789012:role/RoleName" -RoleSessionName "MyRoleSessionName").Credentials
   ```

   `$Creds` ist ein Objekt, das jetzt die Elemente `AccessKeyId`, `SecretAccessKey` und `SessionToken` enthält, die Sie in den folgenden Schritten benötigen. Die folgenden Beispielbefehle veranschaulichen typische Werte:

   ```
   PS C:\> $Creds.AccessKeyId
   AKIAIOSFODNN7EXAMPLE
   
   PS C:\> $Creds.SecretAccessKey
   wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   
   PS C:\> $Creds.SessionToken
   AQoDYXdzEGcaEXAMPLE2gsYULo+Im5ZEXAMPLEeYjs1M2FUIgIJx9tQqNMBEXAMPLECvSRyh0FW7jEXAMPLEW+vE/7s1HRp
   XviG7b+qYf4nD00EXAMPLEmj4wxS04L/uZEXAMPLECihzFB5lTYLto9dyBgSDyEXAMPLE9/g7QRUhZp4bqbEXAMPLENwGPy
   Oj59pFA4lNKCIkVgkREXAMPLEjlzxQ7y52gekeVEXAMPLEDiB9ST3UuysgsKdEXAMPLE1TVastU1A0SKFEXAMPLEiywCC/C
   s8EXAMPLEpZgOs+6hz4AP4KEXAMPLERbASP+4eZScEXAMPLEsnf87eNhyDHq6ikBQ==
   
   PS C:\> $Creds.Expiration
   Thursday, June 18, 2018 2:28:31 PM
   ```

1. Um diese Anmeldeinformationen für nachfolgende Befehle zu verwenden, fügen Sie sie dem `-Credential`-Parameter bei. Der folgende Befehl verwendet beispielsweise die Anmeldeinformationen der Rolle und funktioniert nur dann, wenn der Rolle die `iam:ListRoles`-Berechtigung gewährt wird und sie daher das `Get-IAMRoles`-Cmdlet ausführen kann:

   ```
           PS C:\> get-iamroles -Credential $Creds
   ```

1. Um zu Ihren ursprünglichen Anmeldeinformationen zurückzukehren, beenden Sie einfach die Verwendung des `-Credentials $Creds` Parameters und erlauben Sie PowerShell , zu den Anmeldeinformationen zurückzukehren, die im Standardprofil gespeichert sind.

# Zu einer IAM-Rolle (AWS API) wechseln
<a name="id_roles_use_switch-role-api"></a>

Eine *Rolle* legt eine Gruppe von Berechtigungen fest, die Sie für den Zugriff auf AWS -Ressourcen verwenden können. In dieser Hinsicht ist sie mit einem [IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) vergleichbar. Ein Principal (Person oder Anwendung) übernimmt eine Rolle, um temporäre Berechtigungen zur Ausführung erforderlicher Aufgaben und zur Interaktion mit AWS Ressourcen zu erhalten. Die Rolle kann sich in Ihrem eigenen Konto oder jedem anderen AWS-Konto befinden. Weitere Informationen zu Rollen, ihren Vorteilen sowie zu ihrer Erstellung und Konfiguration finden Sie unter [IAM-Rollen](id_roles.md)und [Erstellung einer IAM-Rolle](id_roles_create.md). 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).

**Wichtig**  
Die Berechtigungen Ihres IAM-Benutzers und alle Rollen, die Sie annehmen, können nicht kumuliert werden. Es ist nur jeweils ein Satz von Berechtigungen aktiv. Wenn Sie eine Rolle annehmen, geben Sie Ihre vorherigen Benutzer- oder Rollenberechtigungen temporär auf und arbeiten mit den Berechtigungen, die der Rolle zugeordnet sind. Wenn Sie die Rolle verlassen, werden Ihre ursprünglichen Benutzerberechtigungen automatisch wiederhergestellt.

Um eine Rolle anzunehmen, ruft eine Anwendung den AWS STS [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API-Vorgang auf und übergibt den ARN der zu verwendenden Rolle. Die Operation erstellt eine neue Sitzung mit temporären Anmeldeinformationen. Diese Sitzung hat die gleichen Berechtigungen wie die identitätsbasierten Richtlinien für diese Rolle. 

Wenn Sie [`AssumeRole` aufrufen](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html), können Sie optional eingebundene oder verwaltete [Sitzungsrichtlinien](access_policies.md#policies_session) übergeben. Sitzungsrichtlinien sind erweiterte Richtlinien, die Sie als Parameter übergeben, wenn Sie programmgesteuert eine Sitzung mit temporären Anmeldeinformationen für eine Rolle oder eine Verbundbenutzersitzung erstellen. Sie können ein einzelnes JSON-Inline-Sitzungsrichtliniendokument mit dem `Policy`-Parameter übergeben. Sie können mit dem Parameter `PolicyArns` bis zu 10 verwaltete Sitzungsrichtlinien angeben. Die resultierenden Sitzungsberechtigungen bilden die Schnittmenge der auf der Identität der Entity basierenden Richtlinien und der Sitzungsrichtlinien. Sitzungsrichtlinien sind praktisch, wenn Sie die temporären Anmeldeinformationen einer Rolle einer anderen Person übergeben müssen. Sie können die temporären Anmeldeinformationen der Rolle in nachfolgenden AWS -API-Aufrufen verwenden, um auf Ressourcen in dem Konto zuzugreifen, zu dem die Rolle gehört. Sie können mit Sitzungsrichtlinien nicht mehr Berechtigungen erteilen, als durch die identitätsbasierte Richtline zulässig sind. Weitere Informationen darüber, wie die effektiven Berechtigungen einer Rolle AWS bestimmt werden, finden Sie unter[Auswertungslogik für Richtlinien](reference_policies_evaluation-logic.md). 

![\[PermissionsWhenPassingRoles_Diagramm\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/role_passed_policy_permissions.png)


Sie können `AssumeRole` aufrufen, wenn Sie als IAM-Benutzer oder als [extern authentifizierter Benutzer](id_roles_providers.md) ([SAML](id_roles_providers_saml.md) oder [OIDC](id_roles_providers_oidc.md)), der eine Rolle bereits verwendet, angemeldet sind. Sie können auch das [*Verketten von Rollen*](id_roles.md#iam-term-role-chaining) verwenden, was bedeutet, eine Rolle zu verwenden, um eine andere Rolle anzunehmen. Sie können keine Rolle anwenden, wenn Sie sich als Root-Benutzer des AWS-Kontos anmelden.

Standardmäßig ist Ihre Rollensitzung eine Stunde gültig. Wenn Sie diese Rolle mithilfe der AWS STS [https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API-Operationen übernehmen, können Sie einen Wert für den `DurationSeconds` Parameter angeben. Dieser Wert kann zwischen 900 Sekunden (15 Minuten) und der maximalen Sitzungsdauer für die Rolle liegen. Weitere Informationen dazu, wie Sie den maximalen Wert für Ihre Rolle anzeigen, 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 Verkettung von Rollen verwenden, ist Ihre Sitzung auf die maximale Dauer von einer Stunde begrenzt. Wenn Sie den `DurationSeconds`-Parameter verwenden, um einen Wert größer als eine Stunde anzugeben, schlägt die Operation fehl.

**Anmerkung**  
Aus Sicherheitsgründen können Administratoren anhand von [AWS CloudTrail Protokollen herausfinden](cloudtrail-integration.md#cloudtrail-integration_signin-tempcreds), wer eine Aktion in ausgeführt hat AWS. Ihr Administrator erfordert möglicherweise, dass Sie einen bestimmten Wert für den Sitzungsnamen angeben, wenn Sie die Rolle übernehmen. Weitere Informationen erhalten Sie unter [`sts:SourceIdentity`](reference_policies_iam-condition-keys.md#ck_sourceidentity) und [`sts:RoleSessionName`](reference_policies_iam-condition-keys.md#ck_rolesessionname).

Die folgenden Codebeispiele veranschaulichen, wie Sie einen Benutzer erstellen und eine Rolle annehmen lassen.

**Warnung**  
Um Sicherheitsrisiken zu vermeiden, sollten Sie IAM-Benutzer nicht zur Authentifizierung verwenden, wenn Sie eigens entwickelte Software entwickeln oder mit echten Daten arbeiten. Verwenden Sie stattdessen den Verbund mit einem Identitätsanbieter wie [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
+ Erstellen Sie einen Benutzer ohne Berechtigungen.
+ Erstellen einer Rolle, die die Berechtigung zum Auflisten von Amazon-S3-Buckets für das Konto erteilt.
+ Hinzufügen einer Richtlinie, damit der Benutzer die Rolle übernehmen kann.
+ Übernehmen Sie die Rolle und listen Sie S3-Buckets mit temporären Anmeldeinformationen auf, und bereinigen Sie dann die Ressourcen.

------
#### [ .NET ]

**SDK für .NET**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/IAM#code-examples) einrichten und ausführen. 

```
global using Amazon.IdentityManagement;
global using Amazon.S3;
global using Amazon.SecurityToken;
global using IAMActions;
global using IamScenariosCommon;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Logging;
global using Microsoft.Extensions.Logging.Console;
global using Microsoft.Extensions.Logging.Debug;


namespace IAMActions;

public class IAMWrapper
{
    private readonly IAmazonIdentityManagementService _IAMService;

    /// <summary>
    /// Constructor for the IAMWrapper class.
    /// </summary>
    /// <param name="IAMService">An IAM client object.</param>
    public IAMWrapper(IAmazonIdentityManagementService IAMService)
    {
        _IAMService = IAMService;
    }

    /// <summary>
    /// Attach an IAM policy to a role.
    /// </summary>
    /// <param name="policyArn">The policy to attach.</param>
    /// <param name="roleName">The role that the policy will be attached to.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> AttachRolePolicyAsync(string policyArn, string roleName)
    {
        var response = await _IAMService.AttachRolePolicyAsync(new AttachRolePolicyRequest
        {
            PolicyArn = policyArn,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Create an IAM access key for a user.
    /// </summary>
    /// <param name="userName">The username for which to create the IAM access
    /// key.</param>
    /// <returns>The AccessKey.</returns>
    public async Task<AccessKey> CreateAccessKeyAsync(string userName)
    {
        var response = await _IAMService.CreateAccessKeyAsync(new CreateAccessKeyRequest
        {
            UserName = userName,
        });

        return response.AccessKey;

    }


    /// <summary>
    /// Create an IAM policy.
    /// </summary>
    /// <param name="policyName">The name to give the new IAM policy.</param>
    /// <param name="policyDocument">The policy document for the new policy.</param>
    /// <returns>The new IAM policy object.</returns>
    public async Task<ManagedPolicy> CreatePolicyAsync(string policyName, string policyDocument)
    {
        var response = await _IAMService.CreatePolicyAsync(new CreatePolicyRequest
        {
            PolicyDocument = policyDocument,
            PolicyName = policyName,
        });

        return response.Policy;
    }


    /// <summary>
    /// Create a new IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="rolePolicyDocument">The name of the IAM policy document
    /// for the new role.</param>
    /// <returns>The Amazon Resource Name (ARN) of the role.</returns>
    public async Task<string> CreateRoleAsync(string roleName, string rolePolicyDocument)
    {
        var request = new CreateRoleRequest
        {
            RoleName = roleName,
            AssumeRolePolicyDocument = rolePolicyDocument,
        };

        var response = await _IAMService.CreateRoleAsync(request);
        return response.Role.Arn;
    }


    /// <summary>
    /// Create an IAM service-linked role.
    /// </summary>
    /// <param name="serviceName">The name of the AWS Service.</param>
    /// <param name="description">A description of the IAM service-linked role.</param>
    /// <returns>The IAM role that was created.</returns>
    public async Task<Role> CreateServiceLinkedRoleAsync(string serviceName, string description)
    {
        var request = new CreateServiceLinkedRoleRequest
        {
            AWSServiceName = serviceName,
            Description = description
        };

        var response = await _IAMService.CreateServiceLinkedRoleAsync(request);
        return response.Role;
    }


    /// <summary>
    /// Create an IAM user.
    /// </summary>
    /// <param name="userName">The username for the new IAM user.</param>
    /// <returns>The IAM user that was created.</returns>
    public async Task<User> CreateUserAsync(string userName)
    {
        var response = await _IAMService.CreateUserAsync(new CreateUserRequest { UserName = userName });
        return response.User;
    }


    /// <summary>
    /// Delete an IAM user's access key.
    /// </summary>
    /// <param name="accessKeyId">The Id for the IAM access key.</param>
    /// <param name="userName">The username of the user that owns the IAM
    /// access key.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteAccessKeyAsync(string accessKeyId, string userName)
    {
        var response = await _IAMService.DeleteAccessKeyAsync(new DeleteAccessKeyRequest
        {
            AccessKeyId = accessKeyId,
            UserName = userName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM policy.
    /// </summary>
    /// <param name="policyArn">The Amazon Resource Name (ARN) of the policy to
    /// delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeletePolicyAsync(string policyArn)
    {
        var response = await _IAMService.DeletePolicyAsync(new DeletePolicyRequest { PolicyArn = policyArn });
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteRoleAsync(string roleName)
    {
        var response = await _IAMService.DeleteRoleAsync(new DeleteRoleRequest { RoleName = roleName });
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM role policy.
    /// </summary>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <param name="policyName">The name of the IAM role policy to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteRolePolicyAsync(string roleName, string policyName)
    {
        var response = await _IAMService.DeleteRolePolicyAsync(new DeleteRolePolicyRequest
        {
            PolicyName = policyName,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM user.
    /// </summary>
    /// <param name="userName">The username of the IAM user to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteUserAsync(string userName)
    {
        var response = await _IAMService.DeleteUserAsync(new DeleteUserRequest { UserName = userName });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Delete an IAM user policy.
    /// </summary>
    /// <param name="policyName">The name of the IAM policy to delete.</param>
    /// <param name="userName">The username of the IAM user.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteUserPolicyAsync(string policyName, string userName)
    {
        var response = await _IAMService.DeleteUserPolicyAsync(new DeleteUserPolicyRequest { PolicyName = policyName, UserName = userName });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Detach an IAM policy from an IAM role.
    /// </summary>
    /// <param name="policyArn">The Amazon Resource Name (ARN) of the IAM policy.</param>
    /// <param name="roleName">The name of the IAM role.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DetachRolePolicyAsync(string policyArn, string roleName)
    {
        var response = await _IAMService.DetachRolePolicyAsync(new DetachRolePolicyRequest
        {
            PolicyArn = policyArn,
            RoleName = roleName,
        });

        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }


    /// <summary>
    /// Gets the IAM password policy for an AWS account.
    /// </summary>
    /// <returns>The PasswordPolicy for the AWS account.</returns>
    public async Task<PasswordPolicy> GetAccountPasswordPolicyAsync()
    {
        var response = await _IAMService.GetAccountPasswordPolicyAsync(new GetAccountPasswordPolicyRequest());
        return response.PasswordPolicy;
    }


    /// <summary>
    /// Get information about an IAM policy.
    /// </summary>
    /// <param name="policyArn">The IAM policy to retrieve information for.</param>
    /// <returns>The IAM policy.</returns>
    public async Task<ManagedPolicy> GetPolicyAsync(string policyArn)
    {

        var response = await _IAMService.GetPolicyAsync(new GetPolicyRequest { PolicyArn = policyArn });
        return response.Policy;
    }


    /// <summary>
    /// Get information about an IAM role.
    /// </summary>
    /// <param name="roleName">The name of the IAM role to retrieve information
    /// for.</param>
    /// <returns>The IAM role that was retrieved.</returns>
    public async Task<Role> GetRoleAsync(string roleName)
    {
        var response = await _IAMService.GetRoleAsync(new GetRoleRequest
        {
            RoleName = roleName,
        });

        return response.Role;
    }


    /// <summary>
    /// Get information about an IAM user.
    /// </summary>
    /// <param name="userName">The username of the user.</param>
    /// <returns>An IAM user object.</returns>
    public async Task<User> GetUserAsync(string userName)
    {
        var response = await _IAMService.GetUserAsync(new GetUserRequest { UserName = userName });
        return response.User;
    }


    /// <summary>
    /// List the IAM role policies that are attached to an IAM role.
    /// </summary>
    /// <param name="roleName">The IAM role to list IAM policies for.</param>
    /// <returns>A list of the IAM policies attached to the IAM role.</returns>
    public async Task<List<AttachedPolicyType>> ListAttachedRolePoliciesAsync(string roleName)
    {
        var attachedPolicies = new List<AttachedPolicyType>();
        var attachedRolePoliciesPaginator = _IAMService.Paginators.ListAttachedRolePolicies(new ListAttachedRolePoliciesRequest { RoleName = roleName });

        await foreach (var response in attachedRolePoliciesPaginator.Responses)
        {
            attachedPolicies.AddRange(response.AttachedPolicies);
        }

        return attachedPolicies;
    }


    /// <summary>
    /// List IAM groups.
    /// </summary>
    /// <returns>A list of IAM groups.</returns>
    public async Task<List<Group>> ListGroupsAsync()
    {
        var groupsPaginator = _IAMService.Paginators.ListGroups(new ListGroupsRequest());
        var groups = new List<Group>();

        await foreach (var response in groupsPaginator.Responses)
        {
            groups.AddRange(response.Groups);
        }

        return groups;
    }


    /// <summary>
    /// List IAM policies.
    /// </summary>
    /// <returns>A list of the IAM policies.</returns>
    public async Task<List<ManagedPolicy>> ListPoliciesAsync()
    {
        var listPoliciesPaginator = _IAMService.Paginators.ListPolicies(new ListPoliciesRequest());
        var policies = new List<ManagedPolicy>();

        await foreach (var response in listPoliciesPaginator.Responses)
        {
            policies.AddRange(response.Policies);
        }

        return policies;
    }


    /// <summary>
    /// List IAM role policies.
    /// </summary>
    /// <param name="roleName">The IAM role for which to list IAM policies.</param>
    /// <returns>A list of IAM policy names.</returns>
    public async Task<List<string>> ListRolePoliciesAsync(string roleName)
    {
        var listRolePoliciesPaginator = _IAMService.Paginators.ListRolePolicies(new ListRolePoliciesRequest { RoleName = roleName });
        var policyNames = new List<string>();

        await foreach (var response in listRolePoliciesPaginator.Responses)
        {
            policyNames.AddRange(response.PolicyNames);
        }

        return policyNames;
    }


    /// <summary>
    /// List IAM roles.
    /// </summary>
    /// <returns>A list of IAM roles.</returns>
    public async Task<List<Role>> ListRolesAsync()
    {
        var listRolesPaginator = _IAMService.Paginators.ListRoles(new ListRolesRequest());
        var roles = new List<Role>();

        await foreach (var response in listRolesPaginator.Responses)
        {
            roles.AddRange(response.Roles);
        }

        return roles;
    }


    /// <summary>
    /// List SAML authentication providers.
    /// </summary>
    /// <returns>A list of SAML providers.</returns>
    public async Task<List<SAMLProviderListEntry>> ListSAMLProvidersAsync()
    {
        var response = await _IAMService.ListSAMLProvidersAsync(new ListSAMLProvidersRequest());
        return response.SAMLProviderList;
    }


    /// <summary>
    /// List IAM users.
    /// </summary>
    /// <returns>A list of IAM users.</returns>
    public async Task<List<User>> ListUsersAsync()
    {
        var listUsersPaginator = _IAMService.Paginators.ListUsers(new ListUsersRequest());
        var users = new List<User>();

        await foreach (var response in listUsersPaginator.Responses)
        {
            users.AddRange(response.Users);
        }

        return users;
    }


    /// <summary>
    /// Update the inline policy document embedded in a role.
    /// </summary>
    /// <param name="policyName">The name of the policy to embed.</param>
    /// <param name="roleName">The name of the role to update.</param>
    /// <param name="policyDocument">The policy document that defines the role.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> PutRolePolicyAsync(string policyName, string roleName, string policyDocument)
    {
        var request = new PutRolePolicyRequest
        {
            PolicyName = policyName,
            RoleName = roleName,
            PolicyDocument = policyDocument
        };

        var response = await _IAMService.PutRolePolicyAsync(request);
        return response.HttpStatusCode == HttpStatusCode.OK;
    }


    /// <summary>
    /// Add or update an inline policy document that is embedded in an IAM user.
    /// </summary>
    /// <param name="userName">The name of the IAM user.</param>
    /// <param name="policyName">The name of the IAM policy.</param>
    /// <param name="policyDocument">The policy document defining the IAM policy.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> PutUserPolicyAsync(string userName, string policyName, string policyDocument)
    {
        var request = new PutUserPolicyRequest
        {
            UserName = userName,
            PolicyName = policyName,
            PolicyDocument = policyDocument
        };

        var response = await _IAMService.PutUserPolicyAsync(request);
        return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
    }

    /// <summary>
    /// Wait for a new access key to be ready to use.
    /// </summary>
    /// <param name="accessKeyId">The Id of the access key.</param>
    /// <returns>A boolean value indicating the success of the action.</returns>
    public async Task<bool> WaitUntilAccessKeyIsReady(string accessKeyId)
    {
        var keyReady = false;

        do
        {
            try
            {
                var response = await _IAMService.GetAccessKeyLastUsedAsync(
                    new GetAccessKeyLastUsedRequest { AccessKeyId = accessKeyId });
                if (response.UserName is not null)
                {
                    keyReady = true;
                }
            }
            catch (NoSuchEntityException)
            {
                keyReady = false;
            }
        } while (!keyReady);

        return keyReady;
    }
}



using Microsoft.Extensions.Configuration;

namespace IAMBasics;

public class IAMBasics
{
    private static ILogger logger = null!;

    static async Task Main(string[] args)
    {
        // Set up dependency injection for the AWS service.
        using var host = Host.CreateDefaultBuilder(args)
            .ConfigureLogging(logging =>
                logging.AddFilter("System", LogLevel.Debug)
                    .AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Information)
                    .AddFilter<ConsoleLoggerProvider>("Microsoft", LogLevel.Trace))
            .ConfigureServices((_, services) =>
            services.AddAWSService<IAmazonIdentityManagementService>()
            .AddTransient<IAMWrapper>()
            .AddTransient<UIWrapper>()
            )
            .Build();

        logger = LoggerFactory.Create(builder => { builder.AddConsole(); })
            .CreateLogger<IAMBasics>();


        IConfiguration configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("settings.json") // Load test settings from .json file.
            .AddJsonFile("settings.local.json",
                true) // Optionally load local settings.
            .Build();

        // Values needed for user, role, and policies.
        string userName = configuration["UserName"]!;
        string s3PolicyName = configuration["S3PolicyName"]!;
        string roleName = configuration["RoleName"]!;


        var iamWrapper = host.Services.GetRequiredService<IAMWrapper>();
        var uiWrapper = host.Services.GetRequiredService<UIWrapper>();

        uiWrapper.DisplayBasicsOverview();
        uiWrapper.PressEnter();

        // First create a user. By default, the new user has
        // no permissions.
        uiWrapper.DisplayTitle("Create User");
        Console.WriteLine($"Creating a new user with user name: {userName}.");
        var user = await iamWrapper.CreateUserAsync(userName);
        var userArn = user.Arn;

        Console.WriteLine($"Successfully created user: {userName} with ARN: {userArn}.");
        uiWrapper.WaitABit(15, "Now let's wait for the user to be ready for use.");

        // Define a role policy document that allows the new user
        // to assume the role.
        string assumeRolePolicyDocument = "{" +
          "\"Version\": \"2012-10-17\"," +
          "\"Statement\": [{" +
              "\"Effect\": \"Allow\"," +
              "\"Principal\": {" +
              $"	\"AWS\": \"{userArn}\"" +
              "}," +
              "\"Action\": \"sts:AssumeRole\"" +
          "}]" +
        "}";

        // Permissions to list all buckets.
        string policyDocument = "{" +
            "\"Version\": \"2012-10-17\"," +
            "	\"Statement\" : [{" +
                "	\"Action\" : [\"s3:ListAllMyBuckets\"]," +
                "	\"Effect\" : \"Allow\"," +
                "	\"Resource\" : \"*\"" +
            "}]" +
        "}";

        // Create an AccessKey for the user.
        uiWrapper.DisplayTitle("Create access key");
        Console.WriteLine("Now let's create an access key for the new user.");
        var accessKey = await iamWrapper.CreateAccessKeyAsync(userName);

        var accessKeyId = accessKey.AccessKeyId;
        var secretAccessKey = accessKey.SecretAccessKey;

        Console.WriteLine($"We have created the access key with Access key id: {accessKeyId}.");

        Console.WriteLine("Now let's wait until the IAM access key is ready to use.");
        var keyReady = await iamWrapper.WaitUntilAccessKeyIsReady(accessKeyId);

        // Now try listing the Amazon Simple Storage Service (Amazon S3)
        // buckets. This should fail at this point because the user doesn't
        // have permissions to perform this task.
        uiWrapper.DisplayTitle("Try to display Amazon S3 buckets");
        Console.WriteLine("Now let's try to display a list of the user's Amazon S3 buckets.");
        var s3Client1 = new AmazonS3Client(accessKeyId, secretAccessKey);
        var stsClient1 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey);

        var s3Wrapper = new S3Wrapper(s3Client1, stsClient1);
        var buckets = await s3Wrapper.ListMyBucketsAsync();

        Console.WriteLine(buckets is null
            ? "As expected, the call to list the buckets has returned a null list."
            : "Something went wrong. This shouldn't have worked.");

        uiWrapper.PressEnter();

        uiWrapper.DisplayTitle("Create IAM role");
        Console.WriteLine($"Creating the role: {roleName}");

        // Creating an IAM role to allow listing the S3 buckets. A role name
        // is not case sensitive and must be unique to the account for which it
        // is created.
        var roleArn = await iamWrapper.CreateRoleAsync(roleName, assumeRolePolicyDocument);

        uiWrapper.PressEnter();

        // Create a policy with permissions to list S3 buckets.
        uiWrapper.DisplayTitle("Create IAM policy");
        Console.WriteLine($"Creating the policy: {s3PolicyName}");
        Console.WriteLine("with permissions to list the Amazon S3 buckets for the account.");
        var policy = await iamWrapper.CreatePolicyAsync(s3PolicyName, policyDocument);

        // Wait 15 seconds for the IAM policy to be available.
        uiWrapper.WaitABit(15, "Waiting for the policy to be available.");

        // Attach the policy to the role you created earlier.
        uiWrapper.DisplayTitle("Attach new IAM policy");
        Console.WriteLine("Now let's attach the policy to the role.");
        await iamWrapper.AttachRolePolicyAsync(policy.Arn, roleName);

        // Wait 15 seconds for the role to be updated.
        Console.WriteLine();
        uiWrapper.WaitABit(15, "Waiting for the policy to be attached.");

        // Use the AWS Security Token Service (AWS STS) to have the user
        // assume the role we created.
        var stsClient2 = new AmazonSecurityTokenServiceClient(accessKeyId, secretAccessKey);

        // Wait for the new credentials to become valid.
        uiWrapper.WaitABit(10, "Waiting for the credentials to be valid.");

        var assumedRoleCredentials = await s3Wrapper.AssumeS3RoleAsync("temporary-session", roleArn);

        // Try again to list the buckets using the client created with
        // the new user's credentials. This time, it should work.
        var s3Client2 = new AmazonS3Client(assumedRoleCredentials);

        s3Wrapper.UpdateClients(s3Client2, stsClient2);

        buckets = await s3Wrapper.ListMyBucketsAsync();

        uiWrapper.DisplayTitle("List Amazon S3 buckets");
        Console.WriteLine("This time we should have buckets to list.");
        if (buckets is not null)
        {
            buckets.ForEach(bucket =>
            {
                Console.WriteLine($"{bucket.BucketName} created: {bucket.CreationDate}");
            });
        }

        uiWrapper.PressEnter();

        // Now clean up all the resources used in the example.
        uiWrapper.DisplayTitle("Clean up resources");
        Console.WriteLine("Thank you for watching. The IAM Basics demo is complete.");
        Console.WriteLine("Please wait while we clean up the resources we created.");

        await iamWrapper.DetachRolePolicyAsync(policy.Arn, roleName);

        await iamWrapper.DeletePolicyAsync(policy.Arn);

        await iamWrapper.DeleteRoleAsync(roleName);

        await iamWrapper.DeleteAccessKeyAsync(accessKeyId, userName);

        await iamWrapper.DeleteUserAsync(userName);

        uiWrapper.PressEnter();

        Console.WriteLine("All done cleaning up our resources. Thank you for your patience.");
    }
}


namespace IamScenariosCommon;

using System.Net;

/// <summary>
/// A class to perform Amazon Simple Storage Service (Amazon S3) actions for
/// the IAM Basics scenario.
/// </summary>
public class S3Wrapper
{
    private IAmazonS3 _s3Service;
    private IAmazonSecurityTokenService _stsService;

    /// <summary>
    /// Constructor for the S3Wrapper class.
    /// </summary>
    /// <param name="s3Service">An Amazon S3 client object.</param>
    /// <param name="stsService">An AWS Security Token Service (AWS STS)
    /// client object.</param>
    public S3Wrapper(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService)
    {
        _s3Service = s3Service;
        _stsService = stsService;
    }

    /// <summary>
    /// Assumes an AWS Identity and Access Management (IAM) role that allows
    /// Amazon S3 access for the current session.
    /// </summary>
    /// <param name="roleSession">A string representing the current session.</param>
    /// <param name="roleToAssume">The name of the IAM role to assume.</param>
    /// <returns>Credentials for the newly assumed IAM role.</returns>
    public async Task<Credentials> AssumeS3RoleAsync(string roleSession, string roleToAssume)
    {
        // Create the request to use with the AssumeRoleAsync call.
        var request = new AssumeRoleRequest()
        {
            RoleSessionName = roleSession,
            RoleArn = roleToAssume,
        };

        var response = await _stsService.AssumeRoleAsync(request);

        return response.Credentials;
    }


    /// <summary>
    /// Delete an S3 bucket.
    /// </summary>
    /// <param name="bucketName">Name of the S3 bucket to delete.</param>
    /// <returns>A Boolean value indicating the success of the action.</returns>
    public async Task<bool> DeleteBucketAsync(string bucketName)
    {
        var result = await _s3Service.DeleteBucketAsync(new DeleteBucketRequest { BucketName = bucketName });
        return result.HttpStatusCode == HttpStatusCode.OK;
    }

    /// <summary>
    /// List the buckets that are owned by the user's account.
    /// </summary>
    /// <returns>Async Task.</returns>
    public async Task<List<S3Bucket>?> ListMyBucketsAsync()
    {
        try
        {
            // Get the list of buckets accessible by the new user.
            var response = await _s3Service.ListBucketsAsync();

            return response.Buckets;
        }
        catch (AmazonS3Exception ex)
        {
            // Something else went wrong. Display the error message.
            Console.WriteLine($"Error: {ex.Message}");
            return null;
        }
    }

    /// <summary>
    /// Create a new S3 bucket.
    /// </summary>
    /// <param name="bucketName">The name for the new bucket.</param>
    /// <returns>A Boolean value indicating whether the action completed
    /// successfully.</returns>
    public async Task<bool> PutBucketAsync(string bucketName)
    {
        var response = await _s3Service.PutBucketAsync(new PutBucketRequest { BucketName = bucketName });
        return response.HttpStatusCode == HttpStatusCode.OK;
    }

    /// <summary>
    /// Update the client objects with new client objects. This is available
    /// because the scenario uses the methods of this class without and then
    /// with the proper permissions to list S3 buckets.
    /// </summary>
    /// <param name="s3Service">The Amazon S3 client object.</param>
    /// <param name="stsService">The AWS STS client object.</param>
    public void UpdateClients(IAmazonS3 s3Service, IAmazonSecurityTokenService stsService)
    {
        _s3Service = s3Service;
        _stsService = stsService;
    }
}


namespace IamScenariosCommon;

public class UIWrapper
{
    public readonly string SepBar = new('-', Console.WindowWidth);

    /// <summary>
    /// Show information about the IAM Groups scenario.
    /// </summary>
    public void DisplayGroupsOverview()
    {
        Console.Clear();

        DisplayTitle("Welcome to the IAM Groups Demo");
        Console.WriteLine("This example application does the following:");
        Console.WriteLine("\t1. Creates an Amazon Identity and Access Management (IAM) group.");
        Console.WriteLine("\t2. Adds an IAM policy to the IAM group giving it full access to Amazon S3.");
        Console.WriteLine("\t3. Creates a new IAM user.");
        Console.WriteLine("\t4. Creates an IAM access key for the user.");
        Console.WriteLine("\t5. Adds the user to the IAM group.");
        Console.WriteLine("\t6. Lists the buckets on the account.");
        Console.WriteLine("\t7. Proves that the user has full Amazon S3 access by creating a bucket.");
        Console.WriteLine("\t8. List the buckets again to show the new bucket.");
        Console.WriteLine("\t9. Cleans up all the resources created.");
    }

    /// <summary>
    /// Show information about the IAM Basics scenario.
    /// </summary>
    public void DisplayBasicsOverview()
    {
        Console.Clear();

        DisplayTitle("Welcome to IAM Basics");
        Console.WriteLine("This example application does the following:");
        Console.WriteLine("\t1. Creates a user with no permissions.");
        Console.WriteLine("\t2. Creates a role and policy that grant s3:ListAllMyBuckets permission.");
        Console.WriteLine("\t3. Grants the user permission to assume the role.");
        Console.WriteLine("\t4. Creates an S3 client object as the user and tries to list buckets (this will fail).");
        Console.WriteLine("\t5. Gets temporary credentials by assuming the role.");
        Console.WriteLine("\t6. Creates a new S3 client object with the temporary credentials and lists the buckets (this will succeed).");
        Console.WriteLine("\t7. Deletes all the resources.");
    }

    /// <summary>
    /// Display a message and wait until the user presses enter.
    /// </summary>
    public void PressEnter()
    {
        Console.Write("\nPress <Enter> to continue. ");
        _ = Console.ReadLine();
        Console.WriteLine();
    }

    /// <summary>
    /// Pad a string with spaces to center it on the console display.
    /// </summary>
    /// <param name="strToCenter">The string to be centered.</param>
    /// <returns>The padded string.</returns>
    public string CenterString(string strToCenter)
    {
        var padAmount = (Console.WindowWidth - strToCenter.Length) / 2;
        var leftPad = new string(' ', padAmount);
        return $"{leftPad}{strToCenter}";
    }

    /// <summary>
    /// Display a line of hyphens, the centered text of the title, and another
    /// line of hyphens.
    /// </summary>
    /// <param name="strTitle">The string to be displayed.</param>
    public void DisplayTitle(string strTitle)
    {
        Console.WriteLine(SepBar);
        Console.WriteLine(CenterString(strTitle));
        Console.WriteLine(SepBar);
    }

    /// <summary>
    /// Display a countdown and wait for a number of seconds.
    /// </summary>
    /// <param name="numSeconds">The number of seconds to wait.</param>
    public void WaitABit(int numSeconds, string msg)
    {
        Console.WriteLine(msg);

        // Wait for the requested number of seconds.
        for (int i = numSeconds; i > 0; i--)
        {
            System.Threading.Thread.Sleep(1000);
            Console.Write($"{i}...");
        }

        PressEnter();
    }
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für .NET -API-Referenz*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Bash ]

**AWS CLI mit Bash-Skript**  
 Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/iam#code-examples) einrichten und ausführen. 

```
###############################################################################
# function iam_create_user_assume_role
#
# Scenario to create an IAM user, create an IAM role, and apply the role to the user.
#
#     "IAM access" permissions are needed to run this code.
#     "STS assume role" permissions are needed to run this code. (Note: It might be necessary to
#           create a custom policy).
#
# Returns:
#       0 - If successful.
#       1 - If an error occurred.
###############################################################################
function iam_create_user_assume_role() {
  {
    if [ "$IAM_OPERATIONS_SOURCED" != "True" ]; then

      source ./iam_operations.sh
    fi
  }

  echo_repeat "*" 88
  echo "Welcome to the IAM create user and assume role demo."
  echo
  echo "This demo will create an IAM user, create an IAM role, and apply the role to the user."
  echo_repeat "*" 88
  echo

  echo -n "Enter a name for a new IAM user: "
  get_input
  user_name=$get_input_result

  local user_arn
  user_arn=$(iam_create_user -u "$user_name")

  # shellcheck disable=SC2181
  if [[ ${?} == 0 ]]; then
    echo "Created demo IAM user named $user_name"
  else
    errecho "$user_arn"
    errecho "The user failed to create. This demo will exit."
    return 1
  fi

  local access_key_response
  access_key_response=$(iam_create_user_access_key -u "$user_name")
  # shellcheck disable=SC2181
  if [[ ${?} != 0 ]]; then
    errecho "The access key failed to create. This demo will exit."
    clean_up "$user_name"
    return 1
  fi

  IFS=$'\t ' read -r -a access_key_values <<<"$access_key_response"
  local key_name=${access_key_values[0]}
  local key_secret=${access_key_values[1]}

  echo "Created access key named $key_name"

  echo "Wait 10 seconds for the user to be ready."
  sleep 10
  echo_repeat "*" 88
  echo

  local iam_role_name
  iam_role_name=$(generate_random_name "test-role")
  echo "Creating a role named $iam_role_name with user $user_name as the principal."

  local assume_role_policy_document="{
    \"Version\": \"2012-10-17\",
    \"Statement\": [{
        \"Effect\": \"Allow\",
        \"Principal\": {\"AWS\": \"$user_arn\"},
        \"Action\": \"sts:AssumeRole\"
        }]
    }"

  local role_arn
  role_arn=$(iam_create_role -n "$iam_role_name" -p "$assume_role_policy_document")

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Created IAM role named $iam_role_name"
  else
    errecho "The role failed to create. This demo will exit."
    clean_up "$user_name" "$key_name"
    return 1
  fi

  local policy_name
  policy_name=$(generate_random_name "test-policy")
  local policy_document="{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]}"

  local policy_arn
  policy_arn=$(iam_create_policy -n "$policy_name" -p "$policy_document")
  # shellcheck disable=SC2181
  if [[ ${?} == 0 ]]; then
    echo "Created  IAM policy named $policy_name"
  else
    errecho "The policy failed to create."
    clean_up "$user_name" "$key_name" "$iam_role_name"
    return 1
  fi

  if (iam_attach_role_policy -n "$iam_role_name" -p "$policy_arn"); then
    echo "Attached policy $policy_arn to role $iam_role_name"
  else
    errecho "The policy failed to attach."
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn"
    return 1
  fi

  local assume_role_policy_document="{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"$role_arn\"}]}"

  local assume_role_policy_name
  assume_role_policy_name=$(generate_random_name "test-assume-role-")

  # shellcheck disable=SC2181
  local assume_role_policy_arn
  assume_role_policy_arn=$(iam_create_policy -n "$assume_role_policy_name" -p "$assume_role_policy_document")
  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Created  IAM policy named $assume_role_policy_name for sts assume role"
  else
    errecho "The policy failed to create."
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn"
    return 1
  fi

  echo "Wait 10 seconds to give AWS time to propagate these new resources and connections."
  sleep 10
  echo_repeat "*" 88
  echo

  echo "Try to list buckets without the new user assuming the role."
  echo_repeat "*" 88
  echo

  # Set the environment variables for the created user.
  # bashsupport disable=BP2001
  export AWS_ACCESS_KEY_ID=$key_name
  # bashsupport disable=BP2001
  export AWS_SECRET_ACCESS_KEY=$key_secret

  local buckets
  buckets=$(s3_list_buckets)

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    local bucket_count
    bucket_count=$(echo "$buckets" | wc -w | xargs)
    echo "There are $bucket_count buckets in the account. This should not have happened."
  else
    errecho "Because the role with permissions has not been assumed, listing buckets failed."
  fi

  echo
  echo_repeat "*" 88
  echo "Now assume the role $iam_role_name and list the buckets."
  echo_repeat "*" 88
  echo

  local credentials

  credentials=$(sts_assume_role -r "$role_arn" -n "AssumeRoleDemoSession")
  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    echo "Assumed role $iam_role_name"
  else
    errecho "Failed to assume role."
    export AWS_ACCESS_KEY_ID=""
    export AWS_SECRET_ACCESS_KEY=""
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"
    return 1
  fi

  IFS=$'\t ' read -r -a credentials <<<"$credentials"

  export AWS_ACCESS_KEY_ID=${credentials[0]}
  export AWS_SECRET_ACCESS_KEY=${credentials[1]}
  # bashsupport disable=BP2001
  export AWS_SESSION_TOKEN=${credentials[2]}

  buckets=$(s3_list_buckets)

  # shellcheck disable=SC2181
  if [ ${?} == 0 ]; then
    local bucket_count
    bucket_count=$(echo "$buckets" | wc -w | xargs)
    echo "There are $bucket_count buckets in the account. Listing buckets succeeded because of "
    echo "the assumed role."
  else
    errecho "Failed to list buckets. This should not happen."
    export AWS_ACCESS_KEY_ID=""
    export AWS_SECRET_ACCESS_KEY=""
    export AWS_SESSION_TOKEN=""
    clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"
    return 1
  fi

  local result=0
  export AWS_ACCESS_KEY_ID=""
  export AWS_SECRET_ACCESS_KEY=""

  echo
  echo_repeat "*" 88
  echo "The created resources will now be deleted."
  echo_repeat "*" 88
  echo

  clean_up "$user_name" "$key_name" "$iam_role_name" "$policy_arn" "$policy_arn" "$assume_role_policy_arn"

  # shellcheck disable=SC2181
  if [[ ${?} -ne 0 ]]; then
    result=1
  fi

  return $result
}
```
Die in diesem Szenario verwendeten IAM-Funktionen.  

```
###############################################################################
# function iam_user_exists
#
# This function checks to see if the specified AWS Identity and Access Management (IAM) user already exists.
#
# Parameters:
#       $1 - The name of the IAM user to check.
#
# Returns:
#       0 - If the user already exists.
#       1 - If the user doesn't exist.
###############################################################################
function iam_user_exists() {
  local user_name
  user_name=$1

  # Check whether the IAM user already exists.
  # We suppress all output - we're interested only in the return code.

  local errors
  errors=$(aws iam get-user \
    --user-name "$user_name" 2>&1 >/dev/null)

  local error_code=${?}

  if [[ $error_code -eq 0 ]]; then
    return 0 # 0 in Bash script means true.
  else
    if [[ $errors != *"error"*"(NoSuchEntity)"* ]]; then
      aws_cli_error_log $error_code
      errecho "Error calling iam get-user $errors"
    fi

    return 1 # 1 in Bash script means false.
  fi
}

###############################################################################
# function iam_create_user
#
# This function creates the specified IAM user, unless
# it already exists.
#
# Parameters:
#       -u user_name  -- The name of the user to create.
#
# Returns:
#       The ARN of the user.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_user() {
  local user_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user"
    echo "Creates an AWS Identity and Access Management (IAM) user. You must supply a username:"
    echo "  -u user_name    The name of the user. It must be unique within the account."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    User name:   $user_name"
  iecho ""

  # If the user already exists, we don't want to try to create it.
  if (iam_user_exists "$user_name"); then
    errecho "ERROR: A user with that name already exists in the account."
    return 1
  fi

  response=$(aws iam create-user --user-name "$user_name" \
    --output text \
    --query 'User.Arn')

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-user operation failed.$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_create_user_access_key
#
# This function creates an IAM access key for the specified user.
#
# Parameters:
#       -u user_name -- The name of the IAM user.
#       [-f file_name] -- The optional file name for the access key output.
#
# Returns:
#       [access_key_id access_key_secret]
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_user_access_key() {
  local user_name file_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) key pair."
    echo "  -u user_name   The name of the IAM user."
    echo "  [-f file_name]   Optional file name for the access key output."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:f:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      f) file_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  response=$(aws iam create-access-key \
    --user-name "$user_name" \
    --output text)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-access-key operation failed.$response"
    return 1
  fi

  if [[ -n "$file_name" ]]; then
    echo "$response" >"$file_name"
  fi

  local key_id key_secret
  # shellcheck disable=SC2086
  key_id=$(echo $response | cut -f 2 -d ' ')
  # shellcheck disable=SC2086
  key_secret=$(echo $response | cut -f 4 -d ' ')

  echo "$key_id $key_secret"

  return 0
}

###############################################################################
# function iam_create_role
#
# This function creates an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_json -- The assume role policy document.
#
# Returns:
#       The ARN of the role.
#     And:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_role() {
  local role_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_user_access_key"
    echo "Creates an AWS Identity and Access Management (IAM) role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_json -- The assume role policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-role \
    --role-name "$role_name" \
    --assume-role-policy-document "$policy_document" \
    --output text \
    --query Role.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-role operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_create_policy
#
# This function creates an IAM policy.
#
# Parameters:
#       -n policy_name -- The name of the IAM policy.
#       -p policy_json -- The policy document.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_create_policy() {
  local policy_name policy_document response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_create_policy"
    echo "Creates an AWS Identity and Access Management (IAM) policy."
    echo "  -n policy_name   The name of the IAM policy."
    echo "  -p policy_json -- The policy document."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) policy_name="${OPTARG}" ;;
      p) policy_document="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$policy_name" ]]; then
    errecho "ERROR: You must provide a policy name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_document" ]]; then
    errecho "ERROR: You must provide a policy document with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam create-policy \
    --policy-name "$policy_name" \
    --policy-document "$policy_document" \
    --output text \
    --query Policy.Arn)

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports create-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"
}

###############################################################################
# function iam_attach_role_policy
#
# This function attaches an IAM policy to a tole.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_ARN -- The IAM policy document ARN..
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_attach_role_policy() {
  local role_name policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_attach_role_policy"
    echo "Attaches an AWS Identity and Access Management (IAM) policy to an IAM role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_ARN -- The IAM policy document ARN."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy ARN with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam attach-role-policy \
    --role-name "$role_name" \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports attach-role-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_detach_role_policy
#
# This function detaches an IAM policy to a tole.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#       -p policy_ARN -- The IAM policy document ARN..
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_detach_role_policy() {
  local role_name policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_detach_role_policy"
    echo "Detaches an AWS Identity and Access Management (IAM) policy to an IAM role."
    echo "  -n role_name   The name of the IAM role."
    echo "  -p policy_ARN -- The IAM policy document ARN."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:p:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      p) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy ARN with the -p parameter."
    usage
    return 1
  fi

  response=$(aws iam detach-role-policy \
    --role-name "$role_name" \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports detach-role-policy operation failed.\n$response"
    return 1
  fi

  echo "$response"

  return 0
}

###############################################################################
# function iam_delete_policy
#
# This function deletes an IAM policy.
#
# Parameters:
#       -n policy_arn -- The name of the IAM policy arn.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_policy() {
  local policy_arn response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_policy"
    echo "Deletes an AWS Identity and Access Management (IAM) policy"
    echo "  -n policy_arn -- The name of the IAM policy arn."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:h" option; do
    case "${option}" in
      n) policy_arn="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$policy_arn" ]]; then
    errecho "ERROR: You must provide a policy arn with the -n parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Policy arn:  $policy_arn"
  iecho ""

  response=$(aws iam delete-policy \
    --policy-arn "$policy_arn")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-policy operation failed.\n$response"
    return 1
  fi

  iecho "delete-policy response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_role
#
# This function deletes an IAM role.
#
# Parameters:
#       -n role_name -- The name of the IAM role.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_role() {
  local role_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_role"
    echo "Deletes an AWS Identity and Access Management (IAM) role"
    echo "  -n role_name -- The name of the IAM role."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "n:h" option; do
    case "${option}" in
      n) role_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  echo "role_name:$role_name"
  if [[ -z "$role_name" ]]; then
    errecho "ERROR: You must provide a role name with the -n parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Role name:  $role_name"
  iecho ""

  response=$(aws iam delete-role \
    --role-name "$role_name")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-role operation failed.\n$response"
    return 1
  fi

  iecho "delete-role response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_access_key
#
# This function deletes an IAM access key for the specified IAM user.
#
# Parameters:
#       -u user_name  -- The name of the user.
#       -k access_key -- The access key to delete.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_access_key() {
  local user_name access_key response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_access_key"
    echo "Deletes an AWS Identity and Access Management (IAM) access key for the specified IAM user"
    echo "  -u user_name    The name of the user."
    echo "  -k access_key   The access key to delete."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:k:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      k) access_key="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  if [[ -z "$access_key" ]]; then
    errecho "ERROR: You must provide an access key with the -k parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    Username:   $user_name"
  iecho "    Access key:   $access_key"
  iecho ""

  response=$(aws iam delete-access-key \
    --user-name "$user_name" \
    --access-key-id "$access_key")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-access-key operation failed.\n$response"
    return 1
  fi

  iecho "delete-access-key response:$response"
  iecho

  return 0
}

###############################################################################
# function iam_delete_user
#
# This function deletes the specified IAM user.
#
# Parameters:
#       -u user_name  -- The name of the user to create.
#
# Returns:
#       0 - If successful.
#       1 - If it fails.
###############################################################################
function iam_delete_user() {
  local user_name response
  local option OPTARG # Required to use getopts command in a function.

  # bashsupport disable=BP5008
  function usage() {
    echo "function iam_delete_user"
    echo "Deletes an AWS Identity and Access Management (IAM) user. You must supply a username:"
    echo "  -u user_name    The name of the user."
    echo ""
  }

  # Retrieve the calling parameters.
  while getopts "u:h" option; do
    case "${option}" in
      u) user_name="${OPTARG}" ;;
      h)
        usage
        return 0
        ;;
      \?)
        echo "Invalid parameter"
        usage
        return 1
        ;;
    esac
  done
  export OPTIND=1

  if [[ -z "$user_name" ]]; then
    errecho "ERROR: You must provide a username with the -u parameter."
    usage
    return 1
  fi

  iecho "Parameters:\n"
  iecho "    User name:   $user_name"
  iecho ""

  # If the user does not exist, we don't want to try to delete it.
  if (! iam_user_exists "$user_name"); then
    errecho "ERROR: A user with that name does not exist in the account."
    return 1
  fi

  response=$(aws iam delete-user \
    --user-name "$user_name")

  local error_code=${?}

  if [[ $error_code -ne 0 ]]; then
    aws_cli_error_log $error_code
    errecho "ERROR: AWS reports delete-user operation failed.$response"
    return 1
  fi

  iecho "delete-user response:$response"
  iecho

  return 0
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS CLI -Befehlsreferenz*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/PutUserPolicy)

------
#### [ C\$1\$1 ]

**SDK für C\$1\$1**  
 Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/iam#code-examples) einrichten und ausführen. 

```
namespace AwsDoc {
    namespace IAM {
  
        //! Cleanup by deleting created entities.
        /*!
          \sa DeleteCreatedEntities
          \param client: IAM client.
          \param role: IAM role.
          \param user: IAM user.
          \param policy: IAM policy.
        */
        static bool DeleteCreatedEntities(const Aws::IAM::IAMClient &client,
                                          const Aws::IAM::Model::Role &role,
                                          const Aws::IAM::Model::User &user,
                                          const Aws::IAM::Model::Policy &policy);
    }

    static const int LIST_BUCKETS_WAIT_SEC = 20;

    static const char ALLOCATION_TAG[] = "example_code";
}

//! Scenario to create an IAM user, create an IAM role, and apply the role to the user.
// "IAM access" permissions are needed to run this code.
// "STS assume role" permissions are needed to run this code. (Note: It might be necessary to
//    create a custom policy).
/*!
  \sa iamCreateUserAssumeRoleScenario
  \param clientConfig: Aws client configuration.
  \return bool: Successful completion.
*/
bool AwsDoc::IAM::iamCreateUserAssumeRoleScenario(
        const Aws::Client::ClientConfiguration &clientConfig) {

    Aws::IAM::IAMClient client(clientConfig);
    Aws::IAM::Model::User user;
    Aws::IAM::Model::Role role;
    Aws::IAM::Model::Policy policy;

    // 1. Create a user.
    {
        Aws::IAM::Model::CreateUserRequest request;
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String userName = "iam-demo-user-" +
                               Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetUserName(userName);

        Aws::IAM::Model::CreateUserOutcome outcome = client.CreateUser(request);
        if (!outcome.IsSuccess()) {
            std::cout << "Error creating IAM user " << userName << ":" <<
                      outcome.GetError().GetMessage() << std::endl;
            return false;
        }
        else {
            std::cout << "Successfully created IAM user " << userName << std::endl;
        }

        user = outcome.GetResult().GetUser();
    }

    // 2. Create a role.
    {
        // Get the IAM user for the current client in order to access its ARN.
        Aws::String iamUserArn;
        {
            Aws::IAM::Model::GetUserRequest request;
            Aws::IAM::Model::GetUserOutcome outcome = client.GetUser(request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error getting Iam user. " <<
                          outcome.GetError().GetMessage() << std::endl;

                DeleteCreatedEntities(client, role, user, policy);
                return false;
            }
            else {
                std::cout << "Successfully retrieved Iam user "
                          << outcome.GetResult().GetUser().GetUserName()
                          << std::endl;
            }

            iamUserArn = outcome.GetResult().GetUser().GetArn();
        }

        Aws::IAM::Model::CreateRoleRequest request;

        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String roleName = "iam-demo-role-" +
                               Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetRoleName(roleName);

        // Build policy document for role.
        Aws::Utils::Document jsonStatement;
        jsonStatement.WithString("Effect", "Allow");

        Aws::Utils::Document jsonPrincipal;
        jsonPrincipal.WithString("AWS", iamUserArn);
        jsonStatement.WithObject("Principal", jsonPrincipal);
        jsonStatement.WithString("Action", "sts:AssumeRole");
        jsonStatement.WithObject("Condition", Aws::Utils::Document());

        Aws::Utils::Document policyDocument;
        policyDocument.WithString("Version", "2012-10-17");

        Aws::Utils::Array<Aws::Utils::Document> statements(1);
        statements[0] = jsonStatement;
        policyDocument.WithArray("Statement", statements);

        std::cout << "Setting policy for role\n   "
                  << policyDocument.View().WriteCompact() << std::endl;

        // Set role policy document as JSON string.
        request.SetAssumeRolePolicyDocument(policyDocument.View().WriteCompact());

        Aws::IAM::Model::CreateRoleOutcome outcome = client.CreateRole(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating role. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully created a role with name " << roleName
                      << std::endl;
        }

        role = outcome.GetResult().GetRole();
    }

    // 3. Create an IAM policy.
    {
        Aws::IAM::Model::CreatePolicyRequest request;
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String policyName = "iam-demo-policy-" +
                                 Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetPolicyName(policyName);

        // Build IAM policy document.
        Aws::Utils::Document jsonStatement;
        jsonStatement.WithString("Effect", "Allow");
        jsonStatement.WithString("Action", "s3:ListAllMyBuckets");
        jsonStatement.WithString("Resource", "arn:aws:s3:::*");

        Aws::Utils::Document policyDocument;
        policyDocument.WithString("Version", "2012-10-17");

        Aws::Utils::Array<Aws::Utils::Document> statements(1);
        statements[0] = jsonStatement;
        policyDocument.WithArray("Statement", statements);

        std::cout << "Creating a policy.\n   " << policyDocument.View().WriteCompact()
                  << std::endl;

        // Set IAM policy document as JSON string.
        request.SetPolicyDocument(policyDocument.View().WriteCompact());

        Aws::IAM::Model::CreatePolicyOutcome outcome = client.CreatePolicy(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating policy. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully created a policy with name, " << policyName <<
                      "." << std::endl;
        }

        policy = outcome.GetResult().GetPolicy();
    }

    // 4. Assume the new role using the AWS Security Token Service (STS).
    Aws::STS::Model::Credentials credentials;
    {
        Aws::STS::STSClient stsClient(clientConfig);

        Aws::STS::Model::AssumeRoleRequest request;
        request.SetRoleArn(role.GetArn());
        Aws::String uuid = Aws::Utils::UUID::RandomUUID();
        Aws::String roleSessionName = "iam-demo-role-session-" +
                                      Aws::Utils::StringUtils::ToLower(uuid.c_str());
        request.SetRoleSessionName(roleSessionName);

        Aws::STS::Model::AssumeRoleOutcome assumeRoleOutcome;

        // Repeatedly call AssumeRole, because there is often a delay
        // before the role is available to be assumed.
        // Repeat at most 20 times when access is denied.
        int count = 0;
        while (true) {
            assumeRoleOutcome = stsClient.AssumeRole(request);
            if (!assumeRoleOutcome.IsSuccess()) {
                if (count > 20 ||
                    assumeRoleOutcome.GetError().GetErrorType() !=
                    Aws::STS::STSErrors::ACCESS_DENIED) {
                    std::cerr << "Error assuming role after 20 tries. " <<
                              assumeRoleOutcome.GetError().GetMessage() << std::endl;

                    DeleteCreatedEntities(client, role, user, policy);
                    return false;
                }
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
            else {
                std::cout << "Successfully assumed the role after " << count
                          << " seconds." << std::endl;
                break;
            }
            count++;
        }

        credentials = assumeRoleOutcome.GetResult().GetCredentials();
    }


    // 5. List objects in the bucket (This should fail).
    {
        Aws::S3::S3Client s3Client(
                Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(),
                                          credentials.GetSecretAccessKey(),
                                          credentials.GetSessionToken()),
                Aws::MakeShared<Aws::S3::S3EndpointProvider>(ALLOCATION_TAG),
                clientConfig);
        Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets();
        if (!listBucketsOutcome.IsSuccess()) {
            if (listBucketsOutcome.GetError().GetErrorType() !=
                Aws::S3::S3Errors::ACCESS_DENIED) {
                std::cerr << "Could not lists buckets. " <<
                          listBucketsOutcome.GetError().GetMessage() << std::endl;
            }
            else {
                std::cout
                        << "Access to list buckets denied because privileges have not been applied."
                        << std::endl;
            }
        }
        else {
            std::cerr
                    << "Successfully retrieved bucket lists when this should not happen."
                    << std::endl;
        }
    }

    // 6. Attach the policy to the role.
    {
        Aws::IAM::Model::AttachRolePolicyRequest request;
        request.SetRoleName(role.GetRoleName());
        request.WithPolicyArn(policy.GetArn());

        Aws::IAM::Model::AttachRolePolicyOutcome outcome = client.AttachRolePolicy(
                request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error creating policy. " <<
                      outcome.GetError().GetMessage() << std::endl;

            DeleteCreatedEntities(client, role, user, policy);
            return false;
        }
        else {
            std::cout << "Successfully attached the policy with name, "
                      << policy.GetPolicyName() <<
                      ", to the role, " << role.GetRoleName() << "." << std::endl;
        }
    }

    int count = 0;
    // 7. List objects in the bucket (this should succeed).
    // Repeatedly call ListBuckets, because there is often a delay
    // before the policy with ListBucket permissions has been applied to the role.
    // Repeat at most LIST_BUCKETS_WAIT_SEC times when access is denied.
    while (true) {
        Aws::S3::S3Client s3Client(
                Aws::Auth::AWSCredentials(credentials.GetAccessKeyId(),
                                          credentials.GetSecretAccessKey(),
                                          credentials.GetSessionToken()),
                Aws::MakeShared<Aws::S3::S3EndpointProvider>(ALLOCATION_TAG),
                clientConfig);
        Aws::S3::Model::ListBucketsOutcome listBucketsOutcome = s3Client.ListBuckets();
        if (!listBucketsOutcome.IsSuccess()) {
            if ((count > LIST_BUCKETS_WAIT_SEC) ||
                listBucketsOutcome.GetError().GetErrorType() !=
                Aws::S3::S3Errors::ACCESS_DENIED) {
                std::cerr << "Could not lists buckets after " << LIST_BUCKETS_WAIT_SEC << " seconds. " <<
                          listBucketsOutcome.GetError().GetMessage() << std::endl;
                DeleteCreatedEntities(client, role, user, policy);
                return false;
            }

            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        else {

            std::cout << "Successfully retrieved bucket lists after " << count
                      << " seconds." << std::endl;
            break;
        }
        count++;
    }

    // 8. Delete all the created resources.
    return DeleteCreatedEntities(client, role, user, policy);
}

bool AwsDoc::IAM::DeleteCreatedEntities(const Aws::IAM::IAMClient &client,
                                        const Aws::IAM::Model::Role &role,
                                        const Aws::IAM::Model::User &user,
                                        const Aws::IAM::Model::Policy &policy) {
    bool result = true;
    if (policy.ArnHasBeenSet()) {
        // Detach the policy from the role.
        {
            Aws::IAM::Model::DetachRolePolicyRequest request;
            request.SetPolicyArn(policy.GetArn());
            request.SetRoleName(role.GetRoleName());

            Aws::IAM::Model::DetachRolePolicyOutcome outcome = client.DetachRolePolicy(
                    request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error Detaching policy from roles. " <<
                          outcome.GetError().GetMessage() << std::endl;
                result = false;
            }
            else {
                std::cout << "Successfully detached the policy with arn "
                          << policy.GetArn()
                          << " from role " << role.GetRoleName() << "." << std::endl;
            }
        }

        // Delete the policy.
        {
            Aws::IAM::Model::DeletePolicyRequest request;
            request.WithPolicyArn(policy.GetArn());

            Aws::IAM::Model::DeletePolicyOutcome outcome = client.DeletePolicy(request);
            if (!outcome.IsSuccess()) {
                std::cerr << "Error deleting policy. " <<
                          outcome.GetError().GetMessage() << std::endl;
                result = false;
            }
            else {
                std::cout << "Successfully deleted the policy with arn "
                          << policy.GetArn() << std::endl;
            }
        }

    }

    if (role.RoleIdHasBeenSet()) {
        // Delete the role.
        Aws::IAM::Model::DeleteRoleRequest request;
        request.SetRoleName(role.GetRoleName());

        Aws::IAM::Model::DeleteRoleOutcome outcome = client.DeleteRole(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error deleting role. " <<
                      outcome.GetError().GetMessage() << std::endl;
            result = false;
        }
        else {
            std::cout << "Successfully deleted the role with name "
                      << role.GetRoleName() << std::endl;
        }
    }

    if (user.ArnHasBeenSet()) {
        // Delete the user.
        Aws::IAM::Model::DeleteUserRequest request;
        request.WithUserName(user.GetUserName());

        Aws::IAM::Model::DeleteUserOutcome outcome = client.DeleteUser(request);
        if (!outcome.IsSuccess()) {
            std::cerr << "Error deleting user. " <<
                      outcome.GetError().GetMessage() << std::endl;
            result = false;
        }
        else {
            std::cout << "Successfully deleted the user with name "
                      << user.GetUserName() << std::endl;
        }
    }

    return result;
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für C\$1\$1 -API-Referenz*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/PutUserPolicy)

------
#### [ Go ]

**SDK für Go V2**  
 Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/iam#code-examples) einrichten und ausführen. 
Führen Sie ein interaktives Szenario an einer Eingabeaufforderung aus.  

```
import (
	"context"
	"errors"
	"fmt"
	"log"
	"math/rand"
	"strings"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/credentials"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/sts"
	"github.com/aws/smithy-go"
	"github.com/awsdocs/aws-doc-sdk-examples/gov2/demotools"
	"github.com/awsdocs/aws-doc-sdk-examples/gov2/iam/actions"
)

// AssumeRoleScenario shows you how to use the AWS Identity and Access Management (IAM)
// service to perform the following actions:
//
//  1. Create a user who has no permissions.
//  2. Create a role that grants permission to list Amazon Simple Storage Service
//     (Amazon S3) buckets for the account.
//  3. Add a policy to let the user assume the role.
//  4. Try and fail to list buckets without permissions.
//  5. Assume the role and list S3 buckets using temporary credentials.
//  6. Delete the policy, role, and user.
type AssumeRoleScenario struct {
	sdkConfig      aws.Config
	accountWrapper actions.AccountWrapper
	policyWrapper  actions.PolicyWrapper
	roleWrapper    actions.RoleWrapper
	userWrapper    actions.UserWrapper
	questioner     demotools.IQuestioner
	helper         IScenarioHelper
	isTestRun      bool
}

// NewAssumeRoleScenario constructs an AssumeRoleScenario instance from a configuration.
// It uses the specified config to get an IAM client and create wrappers for the actions
// used in the scenario.
func NewAssumeRoleScenario(sdkConfig aws.Config, questioner demotools.IQuestioner,
	helper IScenarioHelper) AssumeRoleScenario {
	iamClient := iam.NewFromConfig(sdkConfig)
	return AssumeRoleScenario{
		sdkConfig:      sdkConfig,
		accountWrapper: actions.AccountWrapper{IamClient: iamClient},
		policyWrapper:  actions.PolicyWrapper{IamClient: iamClient},
		roleWrapper:    actions.RoleWrapper{IamClient: iamClient},
		userWrapper:    actions.UserWrapper{IamClient: iamClient},
		questioner:     questioner,
		helper:         helper,
	}
}

// addTestOptions appends the API options specified in the original configuration to
// another configuration. This is used to attach the middleware stubber to clients
// that are constructed during the scenario, which is needed for unit testing.
func (scenario AssumeRoleScenario) addTestOptions(scenarioConfig *aws.Config) {
	if scenario.isTestRun {
		scenarioConfig.APIOptions = append(scenarioConfig.APIOptions, scenario.sdkConfig.APIOptions...)
	}
}

// Run runs the interactive scenario.
func (scenario AssumeRoleScenario) Run(ctx context.Context) {
	defer func() {
		if r := recover(); r != nil {
			log.Printf("Something went wrong with the demo.\n")
			log.Println(r)
		}
	}()

	log.Println(strings.Repeat("-", 88))
	log.Println("Welcome to the AWS Identity and Access Management (IAM) assume role demo.")
	log.Println(strings.Repeat("-", 88))

	user := scenario.CreateUser(ctx)
	accessKey := scenario.CreateAccessKey(ctx, user)
	role := scenario.CreateRoleAndPolicies(ctx, user)
	noPermsConfig := scenario.ListBucketsWithoutPermissions(ctx, accessKey)
	scenario.ListBucketsWithAssumedRole(ctx, noPermsConfig, role)
	scenario.Cleanup(ctx, user, role)

	log.Println(strings.Repeat("-", 88))
	log.Println("Thanks for watching!")
	log.Println(strings.Repeat("-", 88))
}

// CreateUser creates a new IAM user. This user has no permissions.
func (scenario AssumeRoleScenario) CreateUser(ctx context.Context) *types.User {
	log.Println("Let's create an example user with no permissions.")
	userName := scenario.questioner.Ask("Enter a name for the example user:", demotools.NotEmpty{})
	user, err := scenario.userWrapper.GetUser(ctx, userName)
	if err != nil {
		panic(err)
	}
	if user == nil {
		user, err = scenario.userWrapper.CreateUser(ctx, userName)
		if err != nil {
			panic(err)
		}
		log.Printf("Created user %v.\n", *user.UserName)
	} else {
		log.Printf("User %v already exists.\n", *user.UserName)
	}
	log.Println(strings.Repeat("-", 88))
	return user
}

// CreateAccessKey creates an access key for the user.
func (scenario AssumeRoleScenario) CreateAccessKey(ctx context.Context, user *types.User) *types.AccessKey {
	accessKey, err := scenario.userWrapper.CreateAccessKeyPair(ctx, *user.UserName)
	if err != nil {
		panic(err)
	}
	log.Printf("Created access key %v for your user.", *accessKey.AccessKeyId)
	log.Println("Waiting a few seconds for your user to be ready...")
	scenario.helper.Pause(10)
	log.Println(strings.Repeat("-", 88))
	return accessKey
}

// CreateRoleAndPolicies creates a policy that grants permission to list S3 buckets for
// the current account and attaches the policy to a newly created role. It also adds an
// inline policy to the specified user that grants the user permission to assume the role.
func (scenario AssumeRoleScenario) CreateRoleAndPolicies(ctx context.Context, user *types.User) *types.Role {
	log.Println("Let's create a role and policy that grant permission to list S3 buckets.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	listBucketsRole, err := scenario.roleWrapper.CreateRole(ctx, scenario.helper.GetName(), *user.Arn)
	if err != nil {
		panic(err)
	}
	log.Printf("Created role %v.\n", *listBucketsRole.RoleName)
	listBucketsPolicy, err := scenario.policyWrapper.CreatePolicy(
		ctx, scenario.helper.GetName(), []string{"s3:ListAllMyBuckets"}, "arn:aws:s3:::*")
	if err != nil {
		panic(err)
	}
	log.Printf("Created policy %v.\n", *listBucketsPolicy.PolicyName)
	err = scenario.roleWrapper.AttachRolePolicy(ctx, *listBucketsPolicy.Arn, *listBucketsRole.RoleName)
	if err != nil {
		panic(err)
	}
	log.Printf("Attached policy %v to role %v.\n", *listBucketsPolicy.PolicyName,
		*listBucketsRole.RoleName)
	err = scenario.userWrapper.CreateUserPolicy(ctx, *user.UserName, scenario.helper.GetName(),
		[]string{"sts:AssumeRole"}, *listBucketsRole.Arn)
	if err != nil {
		panic(err)
	}
	log.Printf("Created an inline policy for user %v that lets the user assume the role.\n",
		*user.UserName)
	log.Println("Let's give AWS a few seconds to propagate these new resources and connections...")
	scenario.helper.Pause(10)
	log.Println(strings.Repeat("-", 88))
	return listBucketsRole
}

// ListBucketsWithoutPermissions creates an Amazon S3 client from the user's access key
// credentials and tries to list buckets for the account. Because the user does not have
// permission to perform this action, the action fails.
func (scenario AssumeRoleScenario) ListBucketsWithoutPermissions(ctx context.Context, accessKey *types.AccessKey) *aws.Config {
	log.Println("Let's try to list buckets without permissions. This should return an AccessDenied error.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	noPermsConfig, err := config.LoadDefaultConfig(ctx,
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
			*accessKey.AccessKeyId, *accessKey.SecretAccessKey, ""),
		))
	if err != nil {
		panic(err)
	}

	// Add test options if this is a test run. This is needed only for testing purposes.
	scenario.addTestOptions(&noPermsConfig)

	s3Client := s3.NewFromConfig(noPermsConfig)
	_, err = s3Client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		// The SDK for Go does not model the AccessDenied error, so check ErrorCode directly.
		var ae smithy.APIError
		if errors.As(err, &ae) {
			switch ae.ErrorCode() {
			case "AccessDenied":
				log.Println("Got AccessDenied error, which is the expected result because\n" +
					"the ListBuckets call was made without permissions.")
			default:
				log.Println("Expected AccessDenied, got something else.")
				panic(err)
			}
		}
	} else {
		log.Println("Expected AccessDenied error when calling ListBuckets without permissions,\n" +
			"but the call succeeded. Continuing the example anyway...")
	}
	log.Println(strings.Repeat("-", 88))
	return &noPermsConfig
}

// ListBucketsWithAssumedRole performs the following actions:
//
//  1. Creates an AWS Security Token Service (AWS STS) client from the config created from
//     the user's access key credentials.
//  2. Gets temporary credentials by assuming the role that grants permission to list the
//     buckets.
//  3. Creates an Amazon S3 client from the temporary credentials.
//  4. Lists buckets for the account. Because the temporary credentials are generated by
//     assuming the role that grants permission, the action succeeds.
func (scenario AssumeRoleScenario) ListBucketsWithAssumedRole(ctx context.Context, noPermsConfig *aws.Config, role *types.Role) {
	log.Println("Let's assume the role that grants permission to list buckets and try again.")
	scenario.questioner.Ask("Press Enter when you're ready.")
	stsClient := sts.NewFromConfig(*noPermsConfig)
	tempCredentials, err := stsClient.AssumeRole(ctx, &sts.AssumeRoleInput{
		RoleArn:         role.Arn,
		RoleSessionName: aws.String("AssumeRoleExampleSession"),
		DurationSeconds: aws.Int32(900),
	})
	if err != nil {
		log.Printf("Couldn't assume role %v.\n", *role.RoleName)
		panic(err)
	}
	log.Printf("Assumed role %v, got temporary credentials.\n", *role.RoleName)
	assumeRoleConfig, err := config.LoadDefaultConfig(ctx,
		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
			*tempCredentials.Credentials.AccessKeyId,
			*tempCredentials.Credentials.SecretAccessKey,
			*tempCredentials.Credentials.SessionToken),
		),
	)
	if err != nil {
		panic(err)
	}

	// Add test options if this is a test run. This is needed only for testing purposes.
	scenario.addTestOptions(&assumeRoleConfig)

	s3Client := s3.NewFromConfig(assumeRoleConfig)
	result, err := s3Client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		log.Println("Couldn't list buckets with assumed role credentials.")
		panic(err)
	}
	log.Println("Successfully called ListBuckets with assumed role credentials, \n" +
		"here are some of them:")
	for i := 0; i < len(result.Buckets) && i < 5; i++ {
		log.Printf("\t%v\n", *result.Buckets[i].Name)
	}
	log.Println(strings.Repeat("-", 88))
}

// Cleanup deletes all resources created for the scenario.
func (scenario AssumeRoleScenario) Cleanup(ctx context.Context, user *types.User, role *types.Role) {
	if scenario.questioner.AskBool(
		"Do you want to delete the resources created for this example? (y/n)", "y",
	) {
		policies, err := scenario.roleWrapper.ListAttachedRolePolicies(ctx, *role.RoleName)
		if err != nil {
			panic(err)
		}
		for _, policy := range policies {
			err = scenario.roleWrapper.DetachRolePolicy(ctx, *role.RoleName, *policy.PolicyArn)
			if err != nil {
				panic(err)
			}
			err = scenario.policyWrapper.DeletePolicy(ctx, *policy.PolicyArn)
			if err != nil {
				panic(err)
			}
			log.Printf("Detached policy %v from role %v and deleted the policy.\n",
				*policy.PolicyName, *role.RoleName)
		}
		err = scenario.roleWrapper.DeleteRole(ctx, *role.RoleName)
		if err != nil {
			panic(err)
		}
		log.Printf("Deleted role %v.\n", *role.RoleName)

		userPols, err := scenario.userWrapper.ListUserPolicies(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		for _, userPol := range userPols {
			err = scenario.userWrapper.DeleteUserPolicy(ctx, *user.UserName, userPol)
			if err != nil {
				panic(err)
			}
			log.Printf("Deleted policy %v from user %v.\n", userPol, *user.UserName)
		}
		keys, err := scenario.userWrapper.ListAccessKeys(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		for _, key := range keys {
			err = scenario.userWrapper.DeleteAccessKey(ctx, *user.UserName, *key.AccessKeyId)
			if err != nil {
				panic(err)
			}
			log.Printf("Deleted access key %v from user %v.\n", *key.AccessKeyId, *user.UserName)
		}
		err = scenario.userWrapper.DeleteUser(ctx, *user.UserName)
		if err != nil {
			panic(err)
		}
		log.Printf("Deleted user %v.\n", *user.UserName)
		log.Println(strings.Repeat("-", 88))
	}

}

// IScenarioHelper abstracts input and wait functions from a scenario so that they
// can be mocked for unit testing.
type IScenarioHelper interface {
	GetName() string
	Pause(secs int)
}

const rMax = 100000

type ScenarioHelper struct {
	Prefix string
	Random *rand.Rand
}

// GetName returns a unique name formed of a prefix and a random number.
func (helper *ScenarioHelper) GetName() string {
	return fmt.Sprintf("%v%v", helper.Prefix, helper.Random.Intn(rMax))
}

// Pause waits for the specified number of seconds.
func (helper ScenarioHelper) Pause(secs int) {
	time.Sleep(time.Duration(secs) * time.Second)
}
```
Definieren Sie eine Struktur, die Kontoaktionen umschließt.  

```
import (
	"context"
	"log"

	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// AccountWrapper encapsulates AWS Identity and Access Management (IAM) account actions
// used in the examples.
// It contains an IAM service client that is used to perform account actions.
type AccountWrapper struct {
	IamClient *iam.Client
}



// GetAccountPasswordPolicy gets the account password policy for the current account.
// If no policy has been set, a NoSuchEntityException is error is returned.
func (wrapper AccountWrapper) GetAccountPasswordPolicy(ctx context.Context) (*types.PasswordPolicy, error) {
	var pwPolicy *types.PasswordPolicy
	result, err := wrapper.IamClient.GetAccountPasswordPolicy(ctx,
		&iam.GetAccountPasswordPolicyInput{})
	if err != nil {
		log.Printf("Couldn't get account password policy. Here's why: %v\n", err)
	} else {
		pwPolicy = result.PasswordPolicy
	}
	return pwPolicy, err
}



// ListSAMLProviders gets the SAML providers for the account.
func (wrapper AccountWrapper) ListSAMLProviders(ctx context.Context) ([]types.SAMLProviderListEntry, error) {
	var providers []types.SAMLProviderListEntry
	result, err := wrapper.IamClient.ListSAMLProviders(ctx, &iam.ListSAMLProvidersInput{})
	if err != nil {
		log.Printf("Couldn't list SAML providers. Here's why: %v\n", err)
	} else {
		providers = result.SAMLProviderList
	}
	return providers, err
}
```
Definieren Sie eine Struktur, die Richtlinienaktionen umschließt.  

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// PolicyWrapper encapsulates AWS Identity and Access Management (IAM) policy actions
// used in the examples.
// It contains an IAM service client that is used to perform policy actions.
type PolicyWrapper struct {
	IamClient *iam.Client
}



// ListPolicies gets up to maxPolicies policies.
func (wrapper PolicyWrapper) ListPolicies(ctx context.Context, maxPolicies int32) ([]types.Policy, error) {
	var policies []types.Policy
	result, err := wrapper.IamClient.ListPolicies(ctx, &iam.ListPoliciesInput{
		MaxItems: aws.Int32(maxPolicies),
	})
	if err != nil {
		log.Printf("Couldn't list policies. Here's why: %v\n", err)
	} else {
		policies = result.Policies
	}
	return policies, err
}



// PolicyDocument defines a policy document as a Go struct that can be serialized
// to JSON.
type PolicyDocument struct {
	Version   string
	Statement []PolicyStatement
}

// PolicyStatement defines a statement in a policy document.
type PolicyStatement struct {
	Effect    string
	Action    []string
	Principal map[string]string `json:",omitempty"`
	Resource  *string           `json:",omitempty"`
}

// CreatePolicy creates a policy that grants a list of actions to the specified resource.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper PolicyWrapper) CreatePolicy(ctx context.Context, policyName string, actions []string,
	resourceArn string) (*types.Policy, error) {
	var policy *types.Policy
	policyDoc := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:   "Allow",
			Action:   actions,
			Resource: aws.String(resourceArn),
		}},
	}
	policyBytes, err := json.Marshal(policyDoc)
	if err != nil {
		log.Printf("Couldn't create policy document for %v. Here's why: %v\n", resourceArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreatePolicy(ctx, &iam.CreatePolicyInput{
		PolicyDocument: aws.String(string(policyBytes)),
		PolicyName:     aws.String(policyName),
	})
	if err != nil {
		log.Printf("Couldn't create policy %v. Here's why: %v\n", policyName, err)
	} else {
		policy = result.Policy
	}
	return policy, err
}



// GetPolicy gets data about a policy.
func (wrapper PolicyWrapper) GetPolicy(ctx context.Context, policyArn string) (*types.Policy, error) {
	var policy *types.Policy
	result, err := wrapper.IamClient.GetPolicy(ctx, &iam.GetPolicyInput{
		PolicyArn: aws.String(policyArn),
	})
	if err != nil {
		log.Printf("Couldn't get policy %v. Here's why: %v\n", policyArn, err)
	} else {
		policy = result.Policy
	}
	return policy, err
}



// DeletePolicy deletes a policy.
func (wrapper PolicyWrapper) DeletePolicy(ctx context.Context, policyArn string) error {
	_, err := wrapper.IamClient.DeletePolicy(ctx, &iam.DeletePolicyInput{
		PolicyArn: aws.String(policyArn),
	})
	if err != nil {
		log.Printf("Couldn't delete policy %v. Here's why: %v\n", policyArn, err)
	}
	return err
}
```
Definieren Sie eine Struktur, die Rollenaktionen umschließt.  

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
)

// RoleWrapper encapsulates AWS Identity and Access Management (IAM) role actions
// used in the examples.
// It contains an IAM service client that is used to perform role actions.
type RoleWrapper struct {
	IamClient *iam.Client
}



// ListRoles gets up to maxRoles roles.
func (wrapper RoleWrapper) ListRoles(ctx context.Context, maxRoles int32) ([]types.Role, error) {
	var roles []types.Role
	result, err := wrapper.IamClient.ListRoles(ctx,
		&iam.ListRolesInput{MaxItems: aws.Int32(maxRoles)},
	)
	if err != nil {
		log.Printf("Couldn't list roles. Here's why: %v\n", err)
	} else {
		roles = result.Roles
	}
	return roles, err
}



// CreateRole creates a role that trusts a specified user. The trusted user can assume
// the role to acquire its permissions.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper RoleWrapper) CreateRole(ctx context.Context, roleName string, trustedUserArn string) (*types.Role, error) {
	var role *types.Role
	trustPolicy := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:    "Allow",
			Principal: map[string]string{"AWS": trustedUserArn},
			Action:    []string{"sts:AssumeRole"},
		}},
	}
	policyBytes, err := json.Marshal(trustPolicy)
	if err != nil {
		log.Printf("Couldn't create trust policy for %v. Here's why: %v\n", trustedUserArn, err)
		return nil, err
	}
	result, err := wrapper.IamClient.CreateRole(ctx, &iam.CreateRoleInput{
		AssumeRolePolicyDocument: aws.String(string(policyBytes)),
		RoleName:                 aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't create role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// GetRole gets data about a role.
func (wrapper RoleWrapper) GetRole(ctx context.Context, roleName string) (*types.Role, error) {
	var role *types.Role
	result, err := wrapper.IamClient.GetRole(ctx,
		&iam.GetRoleInput{RoleName: aws.String(roleName)})
	if err != nil {
		log.Printf("Couldn't get role %v. Here's why: %v\n", roleName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// CreateServiceLinkedRole creates a service-linked role that is owned by the specified service.
func (wrapper RoleWrapper) CreateServiceLinkedRole(ctx context.Context, serviceName string, description string) (
	*types.Role, error) {
	var role *types.Role
	result, err := wrapper.IamClient.CreateServiceLinkedRole(ctx, &iam.CreateServiceLinkedRoleInput{
		AWSServiceName: aws.String(serviceName),
		Description:    aws.String(description),
	})
	if err != nil {
		log.Printf("Couldn't create service-linked role %v. Here's why: %v\n", serviceName, err)
	} else {
		role = result.Role
	}
	return role, err
}



// DeleteServiceLinkedRole deletes a service-linked role.
func (wrapper RoleWrapper) DeleteServiceLinkedRole(ctx context.Context, roleName string) error {
	_, err := wrapper.IamClient.DeleteServiceLinkedRole(ctx, &iam.DeleteServiceLinkedRoleInput{
		RoleName: aws.String(roleName)},
	)
	if err != nil {
		log.Printf("Couldn't delete service-linked role %v. Here's why: %v\n", roleName, err)
	}
	return err
}



// AttachRolePolicy attaches a policy to a role.
func (wrapper RoleWrapper) AttachRolePolicy(ctx context.Context, policyArn string, roleName string) error {
	_, err := wrapper.IamClient.AttachRolePolicy(ctx, &iam.AttachRolePolicyInput{
		PolicyArn: aws.String(policyArn),
		RoleName:  aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't attach policy %v to role %v. Here's why: %v\n", policyArn, roleName, err)
	}
	return err
}



// ListAttachedRolePolicies lists the policies that are attached to the specified role.
func (wrapper RoleWrapper) ListAttachedRolePolicies(ctx context.Context, roleName string) ([]types.AttachedPolicy, error) {
	var policies []types.AttachedPolicy
	result, err := wrapper.IamClient.ListAttachedRolePolicies(ctx, &iam.ListAttachedRolePoliciesInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't list attached policies for role %v. Here's why: %v\n", roleName, err)
	} else {
		policies = result.AttachedPolicies
	}
	return policies, err
}



// DetachRolePolicy detaches a policy from a role.
func (wrapper RoleWrapper) DetachRolePolicy(ctx context.Context, roleName string, policyArn string) error {
	_, err := wrapper.IamClient.DetachRolePolicy(ctx, &iam.DetachRolePolicyInput{
		PolicyArn: aws.String(policyArn),
		RoleName:  aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't detach policy from role %v. Here's why: %v\n", roleName, err)
	}
	return err
}



// ListRolePolicies lists the inline policies for a role.
func (wrapper RoleWrapper) ListRolePolicies(ctx context.Context, roleName string) ([]string, error) {
	var policies []string
	result, err := wrapper.IamClient.ListRolePolicies(ctx, &iam.ListRolePoliciesInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't list policies for role %v. Here's why: %v\n", roleName, err)
	} else {
		policies = result.PolicyNames
	}
	return policies, err
}



// DeleteRole deletes a role. All attached policies must be detached before a
// role can be deleted.
func (wrapper RoleWrapper) DeleteRole(ctx context.Context, roleName string) error {
	_, err := wrapper.IamClient.DeleteRole(ctx, &iam.DeleteRoleInput{
		RoleName: aws.String(roleName),
	})
	if err != nil {
		log.Printf("Couldn't delete role %v. Here's why: %v\n", roleName, err)
	}
	return err
}
```
Definieren Sie eine Struktur, die Benutzeraktionen umschließt.  

```
import (
	"context"
	"encoding/json"
	"errors"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/iam"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
	"github.com/aws/smithy-go"
)

// UserWrapper encapsulates user actions used in the examples.
// It contains an IAM service client that is used to perform user actions.
type UserWrapper struct {
	IamClient *iam.Client
}



// ListUsers gets up to maxUsers number of users.
func (wrapper UserWrapper) ListUsers(ctx context.Context, maxUsers int32) ([]types.User, error) {
	var users []types.User
	result, err := wrapper.IamClient.ListUsers(ctx, &iam.ListUsersInput{
		MaxItems: aws.Int32(maxUsers),
	})
	if err != nil {
		log.Printf("Couldn't list users. Here's why: %v\n", err)
	} else {
		users = result.Users
	}
	return users, err
}



// GetUser gets data about a user.
func (wrapper UserWrapper) GetUser(ctx context.Context, userName string) (*types.User, error) {
	var user *types.User
	result, err := wrapper.IamClient.GetUser(ctx, &iam.GetUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		var apiError smithy.APIError
		if errors.As(err, &apiError) {
			switch apiError.(type) {
			case *types.NoSuchEntityException:
				log.Printf("User %v does not exist.\n", userName)
				err = nil
			default:
				log.Printf("Couldn't get user %v. Here's why: %v\n", userName, err)
			}
		}
	} else {
		user = result.User
	}
	return user, err
}



// CreateUser creates a new user with the specified name.
func (wrapper UserWrapper) CreateUser(ctx context.Context, userName string) (*types.User, error) {
	var user *types.User
	result, err := wrapper.IamClient.CreateUser(ctx, &iam.CreateUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't create user %v. Here's why: %v\n", userName, err)
	} else {
		user = result.User
	}
	return user, err
}



// CreateUserPolicy adds an inline policy to a user. This example creates a policy that
// grants a list of actions on a specified role.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper UserWrapper) CreateUserPolicy(ctx context.Context, userName string, policyName string, actions []string,
	roleArn string) error {
	policyDoc := PolicyDocument{
		Version: "2012-10-17",
		Statement: []PolicyStatement{{
			Effect:   "Allow",
			Action:   actions,
			Resource: aws.String(roleArn),
		}},
	}
	policyBytes, err := json.Marshal(policyDoc)
	if err != nil {
		log.Printf("Couldn't create policy document for %v. Here's why: %v\n", roleArn, err)
		return err
	}
	_, err = wrapper.IamClient.PutUserPolicy(ctx, &iam.PutUserPolicyInput{
		PolicyDocument: aws.String(string(policyBytes)),
		PolicyName:     aws.String(policyName),
		UserName:       aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't create policy for user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// ListUserPolicies lists the inline policies for the specified user.
func (wrapper UserWrapper) ListUserPolicies(ctx context.Context, userName string) ([]string, error) {
	var policies []string
	result, err := wrapper.IamClient.ListUserPolicies(ctx, &iam.ListUserPoliciesInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't list policies for user %v. Here's why: %v\n", userName, err)
	} else {
		policies = result.PolicyNames
	}
	return policies, err
}



// DeleteUserPolicy deletes an inline policy from a user.
func (wrapper UserWrapper) DeleteUserPolicy(ctx context.Context, userName string, policyName string) error {
	_, err := wrapper.IamClient.DeleteUserPolicy(ctx, &iam.DeleteUserPolicyInput{
		PolicyName: aws.String(policyName),
		UserName:   aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete policy from user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// DeleteUser deletes a user.
func (wrapper UserWrapper) DeleteUser(ctx context.Context, userName string) error {
	_, err := wrapper.IamClient.DeleteUser(ctx, &iam.DeleteUserInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete user %v. Here's why: %v\n", userName, err)
	}
	return err
}



// CreateAccessKeyPair creates an access key for a user. The returned access key contains
// the ID and secret credentials needed to use the key.
func (wrapper UserWrapper) CreateAccessKeyPair(ctx context.Context, userName string) (*types.AccessKey, error) {
	var key *types.AccessKey
	result, err := wrapper.IamClient.CreateAccessKey(ctx, &iam.CreateAccessKeyInput{
		UserName: aws.String(userName)})
	if err != nil {
		log.Printf("Couldn't create access key pair for user %v. Here's why: %v\n", userName, err)
	} else {
		key = result.AccessKey
	}
	return key, err
}



// DeleteAccessKey deletes an access key from a user.
func (wrapper UserWrapper) DeleteAccessKey(ctx context.Context, userName string, keyId string) error {
	_, err := wrapper.IamClient.DeleteAccessKey(ctx, &iam.DeleteAccessKeyInput{
		AccessKeyId: aws.String(keyId),
		UserName:    aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't delete access key %v. Here's why: %v\n", keyId, err)
	}
	return err
}



// ListAccessKeys lists the access keys for the specified user.
func (wrapper UserWrapper) ListAccessKeys(ctx context.Context, userName string) ([]types.AccessKeyMetadata, error) {
	var keys []types.AccessKeyMetadata
	result, err := wrapper.IamClient.ListAccessKeys(ctx, &iam.ListAccessKeysInput{
		UserName: aws.String(userName),
	})
	if err != nil {
		log.Printf("Couldn't list access keys for user %v. Here's why: %v\n", userName, err)
	} else {
		keys = result.AccessKeyMetadata
	}
	return keys, err
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für Go -API-Referenz*.
  + [AttachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.AttachRolePolicy)
  + [CreateAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateAccessKey)
  + [CreatePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreatePolicy)
  + [CreateRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateRole)
  + [CreateUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateUser)
  + [DeleteAccessKey](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteAccessKey)
  + [DeletePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeletePolicy)
  + [DeleteRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteRole)
  + [DeleteUser](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUser)
  + [DeleteUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DeleteUserPolicy)
  + [DetachRolePolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.DetachRolePolicy)
  + [PutUserPolicy](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.PutUserPolicy)

------
#### [ Java ]

**SDK für Java 2.x**  
 Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/iam#code-examples) einrichten und ausführen. 
Erstellen Sie Funktionen, die IAM-Benutzer-Aktionen umschließen.  

```
/*
  To run this Java V2 code example, set up your development environment, including your credentials.

  For information, see this documentation topic:

  https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html

  This example performs these operations:

  1. Creates a user that has no permissions.
  2. Creates a role and policy that grants Amazon S3 permissions.
  3. Creates a role.
  4. Grants the user permissions.
  5. Gets temporary credentials by assuming the role.  Creates an Amazon S3 Service client object with the temporary credentials.
  6. Deletes the resources.
 */

public class IAMScenario {
    public static final String DASHES = new String(new char[80]).replace("\0", "-");
    public static final String PolicyDocument = "{" +
            "  \"Version\": \"2012-10-17\"," +
            "  \"Statement\": [" +
            "    {" +
            "        \"Effect\": \"Allow\"," +
            "        \"Action\": [" +
            "            \"s3:*\"" +
            "       ]," +
            "       \"Resource\": \"*\"" +
            "    }" +
            "   ]" +
            "}";

    public static String userArn;

    public static void main(String[] args) throws Exception {

        final String usage = """

                Usage:
                    <username> <policyName> <roleName> <roleSessionName> <bucketName>\s

                Where:
                    username - The name of the IAM user to create.\s
                    policyName - The name of the policy to create.\s
                    roleName - The name of the role to create.\s
                    roleSessionName - The name of the session required for the assumeRole operation.\s
                    bucketName - The name of the Amazon S3 bucket from which objects are read.\s
                """;

        if (args.length != 5) {
            System.out.println(usage);
            System.exit(1);
        }

        String userName = args[0];
        String policyName = args[1];
        String roleName = args[2];
        String roleSessionName = args[3];
        String bucketName = args[4];

        Region region = Region.AWS_GLOBAL;
        IamClient iam = IamClient.builder()
                .region(region)
                .build();

        System.out.println(DASHES);
        System.out.println("Welcome to the AWS IAM example scenario.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println(" 1. Create the IAM user.");
        User createUser = createIAMUser(iam, userName);

        System.out.println(DASHES);
        userArn = createUser.arn();

        AccessKey myKey = createIAMAccessKey(iam, userName);
        String accessKey = myKey.accessKeyId();
        String secretKey = myKey.secretAccessKey();
        String assumeRolePolicyDocument = "{" +
                "\"Version\": \"2012-10-17\"," +
                "\"Statement\": [{" +
                "\"Effect\": \"Allow\"," +
                "\"Principal\": {" +
                "	\"AWS\": \"" + userArn + "\"" +
                "}," +
                "\"Action\": \"sts:AssumeRole\"" +
                "}]" +
                "}";

        System.out.println(assumeRolePolicyDocument);
        System.out.println(userName + " was successfully created.");
        System.out.println(DASHES);
        System.out.println("2. Creates a policy.");
        String polArn = createIAMPolicy(iam, policyName);
        System.out.println("The policy " + polArn + " was successfully created.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("3. Creates a role.");
        TimeUnit.SECONDS.sleep(30);
        String roleArn = createIAMRole(iam, roleName, assumeRolePolicyDocument);
        System.out.println(roleArn + " was successfully created.");
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("4. Grants the user permissions.");
        attachIAMRolePolicy(iam, roleName, polArn);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("*** Wait for 30 secs so the resource is available");
        TimeUnit.SECONDS.sleep(30);
        System.out.println("5. Gets temporary credentials by assuming the role.");
        System.out.println("Perform an Amazon S3 Service operation using the temporary credentials.");
        assumeRole(roleArn, roleSessionName, bucketName, accessKey, secretKey);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("6 Getting ready to delete the AWS resources");
        deleteKey(iam, userName, accessKey);
        deleteRole(iam, roleName, polArn);
        deleteIAMUser(iam, userName);
        System.out.println(DASHES);

        System.out.println(DASHES);
        System.out.println("This IAM Scenario has successfully completed");
        System.out.println(DASHES);
    }

    public static AccessKey createIAMAccessKey(IamClient iam, String user) {
        try {
            CreateAccessKeyRequest request = CreateAccessKeyRequest.builder()
                    .userName(user)
                    .build();

            CreateAccessKeyResponse response = iam.createAccessKey(request);
            return response.accessKey();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }

    public static User createIAMUser(IamClient iam, String username) {
        try {
            // Create an IamWaiter object
            IamWaiter iamWaiter = iam.waiter();
            CreateUserRequest request = CreateUserRequest.builder()
                    .userName(username)
                    .build();

            // Wait until the user is created.
            CreateUserResponse response = iam.createUser(request);
            GetUserRequest userRequest = GetUserRequest.builder()
                    .userName(response.user().userName())
                    .build();

            WaiterResponse<GetUserResponse> waitUntilUserExists = iamWaiter.waitUntilUserExists(userRequest);
            waitUntilUserExists.matched().response().ifPresent(System.out::println);
            return response.user();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }

    public static String createIAMRole(IamClient iam, String rolename, String json) {

        try {
            CreateRoleRequest request = CreateRoleRequest.builder()
                    .roleName(rolename)
                    .assumeRolePolicyDocument(json)
                    .description("Created using the AWS SDK for Java")
                    .build();

            CreateRoleResponse response = iam.createRole(request);
            System.out.println("The ARN of the role is " + response.role().arn());
            return response.role().arn();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static String createIAMPolicy(IamClient iam, String policyName) {
        try {
            // Create an IamWaiter object.
            IamWaiter iamWaiter = iam.waiter();
            CreatePolicyRequest request = CreatePolicyRequest.builder()
                    .policyName(policyName)
                    .policyDocument(PolicyDocument).build();

            CreatePolicyResponse response = iam.createPolicy(request);
            GetPolicyRequest polRequest = GetPolicyRequest.builder()
                    .policyArn(response.policy().arn())
                    .build();

            WaiterResponse<GetPolicyResponse> waitUntilPolicyExists = iamWaiter.waitUntilPolicyExists(polRequest);
            waitUntilPolicyExists.matched().response().ifPresent(System.out::println);
            return response.policy().arn();

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }

    public static void attachIAMRolePolicy(IamClient iam, String roleName, String policyArn) {
        try {
            ListAttachedRolePoliciesRequest request = ListAttachedRolePoliciesRequest.builder()
                    .roleName(roleName)
                    .build();

            ListAttachedRolePoliciesResponse response = iam.listAttachedRolePolicies(request);
            List<AttachedPolicy> attachedPolicies = response.attachedPolicies();
            String polArn;
            for (AttachedPolicy policy : attachedPolicies) {
                polArn = policy.policyArn();
                if (polArn.compareTo(policyArn) == 0) {
                    System.out.println(roleName + " policy is already attached to this role.");
                    return;
                }
            }

            AttachRolePolicyRequest attachRequest = AttachRolePolicyRequest.builder()
                    .roleName(roleName)
                    .policyArn(policyArn)
                    .build();

            iam.attachRolePolicy(attachRequest);
            System.out.println("Successfully attached policy " + policyArn + " to role " + roleName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    // Invoke an Amazon S3 operation using the Assumed Role.
    public static void assumeRole(String roleArn, String roleSessionName, String bucketName, String keyVal,
            String keySecret) {

        // Use the creds of the new IAM user that was created in this code example.
        AwsBasicCredentials credentials = AwsBasicCredentials.create(keyVal, keySecret);
        StsClient stsClient = StsClient.builder()
                .region(Region.US_EAST_1)
                .credentialsProvider(StaticCredentialsProvider.create(credentials))
                .build();

        try {
            AssumeRoleRequest roleRequest = AssumeRoleRequest.builder()
                    .roleArn(roleArn)
                    .roleSessionName(roleSessionName)
                    .build();

            AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest);
            Credentials myCreds = roleResponse.credentials();
            String key = myCreds.accessKeyId();
            String secKey = myCreds.secretAccessKey();
            String secToken = myCreds.sessionToken();

            // List all objects in an Amazon S3 bucket using the temp creds retrieved by
            // invoking assumeRole.
            Region region = Region.US_EAST_1;
            S3Client s3 = S3Client.builder()
                    .credentialsProvider(
                            StaticCredentialsProvider.create(AwsSessionCredentials.create(key, secKey, secToken)))
                    .region(region)
                    .build();

            System.out.println("Created a S3Client using temp credentials.");
            System.out.println("Listing objects in " + bucketName);
            ListObjectsRequest listObjects = ListObjectsRequest.builder()
                    .bucket(bucketName)
                    .build();

            ListObjectsResponse res = s3.listObjects(listObjects);
            List<S3Object> objects = res.contents();
            for (S3Object myValue : objects) {
                System.out.println("The name of the key is " + myValue.key());
                System.out.println("The owner is " + myValue.owner());
            }

        } catch (StsException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }
    }

    public static void deleteRole(IamClient iam, String roleName, String polArn) {

        try {
            // First the policy needs to be detached.
            DetachRolePolicyRequest rolePolicyRequest = DetachRolePolicyRequest.builder()
                    .policyArn(polArn)
                    .roleName(roleName)
                    .build();

            iam.detachRolePolicy(rolePolicyRequest);

            // Delete the policy.
            DeletePolicyRequest request = DeletePolicyRequest.builder()
                    .policyArn(polArn)
                    .build();

            iam.deletePolicy(request);
            System.out.println("*** Successfully deleted " + polArn);

            // Delete the role.
            DeleteRoleRequest roleRequest = DeleteRoleRequest.builder()
                    .roleName(roleName)
                    .build();

            iam.deleteRole(roleRequest);
            System.out.println("*** Successfully deleted " + roleName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void deleteKey(IamClient iam, String username, String accessKey) {
        try {
            DeleteAccessKeyRequest request = DeleteAccessKeyRequest.builder()
                    .accessKeyId(accessKey)
                    .userName(username)
                    .build();

            iam.deleteAccessKey(request);
            System.out.println("Successfully deleted access key " + accessKey +
                    " from user " + username);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void deleteIAMUser(IamClient iam, String userName) {
        try {
            DeleteUserRequest request = DeleteUserRequest.builder()
                    .userName(userName)
                    .build();

            iam.deleteUser(request);
            System.out.println("*** Successfully deleted " + userName);

        } catch (IamException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK for Java 2.x -API-Referenz*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/PutUserPolicy)

------
#### [ JavaScript ]

**SDK für JavaScript (v3)**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/iam#code-examples) einrichten und ausführen. 
Erstellen Sie einen IAM-Benutzer und eine Rolle, die die Berechtigung zum Auflisten von Amazon-S3-Buckets erteilt. Der Benutzer hat nur Rechte, um die Rolle anzunehmen. Nachdem Sie die Rolle übernommen haben, verwenden Sie temporäre Anmeldeinformationen, um Buckets für das Konto aufzulisten.  

```
import {
  CreateUserCommand,
  GetUserCommand,
  CreateAccessKeyCommand,
  CreatePolicyCommand,
  CreateRoleCommand,
  AttachRolePolicyCommand,
  DeleteAccessKeyCommand,
  DeleteUserCommand,
  DeleteRoleCommand,
  DeletePolicyCommand,
  DetachRolePolicyCommand,
  IAMClient,
} from "@aws-sdk/client-iam";
import { ListBucketsCommand, S3Client } from "@aws-sdk/client-s3";
import { AssumeRoleCommand, STSClient } from "@aws-sdk/client-sts";
import { retry } from "@aws-doc-sdk-examples/lib/utils/util-timers.js";
import { ScenarioInput } from "@aws-doc-sdk-examples/lib/scenario/index.js";

// Set the parameters.
const iamClient = new IAMClient({});
const userName = "iam_basic_test_username";
const policyName = "iam_basic_test_policy";
const roleName = "iam_basic_test_role";

/**
 * Create a new IAM user. If the user already exists, give
 * the option to delete and re-create it.
 * @param {string} name
 */
export const createUser = async (name, confirmAll = false) => {
  try {
    const { User } = await iamClient.send(
      new GetUserCommand({ UserName: name }),
    );
    const input = new ScenarioInput(
      "deleteUser",
      "Do you want to delete and remake this user?",
      { type: "confirm" },
    );
    const deleteUser = await input.handle({}, { confirmAll });
    // If the user exists, and you want to delete it, delete the user
    // and then create it again.
    if (deleteUser) {
      await iamClient.send(new DeleteUserCommand({ UserName: User.UserName }));
      await iamClient.send(new CreateUserCommand({ UserName: name }));
    } else {
      console.warn(
        `${name} already exists. The scenario may not work as expected.`,
      );
      return User;
    }
  } catch (caught) {
    // If there is no user by that name, create one.
    if (caught instanceof Error && caught.name === "NoSuchEntityException") {
      const { User } = await iamClient.send(
        new CreateUserCommand({ UserName: name }),
      );
      return User;
    }
    throw caught;
  }
};

export const main = async (confirmAll = false) => {
  // Create a user. The user has no permissions by default.
  const User = await createUser(userName, confirmAll);

  if (!User) {
    throw new Error("User not created");
  }

  // Create an access key. This key is used to authenticate the new user to
  // Amazon Simple Storage Service (Amazon S3) and AWS Security Token Service (AWS STS).
  // It's not best practice to use access keys. For more information, see https://aws.amazon.com/iam/resources/best-practices/.
  const createAccessKeyResponse = await iamClient.send(
    new CreateAccessKeyCommand({ UserName: userName }),
  );

  if (
    !createAccessKeyResponse.AccessKey?.AccessKeyId ||
    !createAccessKeyResponse.AccessKey?.SecretAccessKey
  ) {
    throw new Error("Access key not created");
  }

  const {
    AccessKey: { AccessKeyId, SecretAccessKey },
  } = createAccessKeyResponse;

  let s3Client = new S3Client({
    credentials: {
      accessKeyId: AccessKeyId,
      secretAccessKey: SecretAccessKey,
    },
  });

  // Retry the list buckets operation until it succeeds. InvalidAccessKeyId is
  // thrown while the user and access keys are still stabilizing.
  await retry({ intervalInMs: 1000, maxRetries: 300 }, async () => {
    try {
      return await listBuckets(s3Client);
    } catch (err) {
      if (err instanceof Error && err.name === "InvalidAccessKeyId") {
        throw err;
      }
    }
  });

  // Retry the create role operation until it succeeds. A MalformedPolicyDocument error
  // is thrown while the user and access keys are still stabilizing.
  const { Role } = await retry(
    {
      intervalInMs: 2000,
      maxRetries: 60,
    },
    () =>
      iamClient.send(
        new CreateRoleCommand({
          AssumeRolePolicyDocument: JSON.stringify({
            Version: "2012-10-17",
            Statement: [
              {
                Effect: "Allow",
                Principal: {
                  // Allow the previously created user to assume this role.
                  AWS: User.Arn,
                },
                Action: "sts:AssumeRole",
              },
            ],
          }),
          RoleName: roleName,
        }),
      ),
  );

  if (!Role) {
    throw new Error("Role not created");
  }

  // Create a policy that allows the user to list S3 buckets.
  const { Policy: listBucketPolicy } = await iamClient.send(
    new CreatePolicyCommand({
      PolicyDocument: JSON.stringify({
        Version: "2012-10-17",
        Statement: [
          {
            Effect: "Allow",
            Action: ["s3:ListAllMyBuckets"],
            Resource: "*",
          },
        ],
      }),
      PolicyName: policyName,
    }),
  );

  if (!listBucketPolicy) {
    throw new Error("Policy not created");
  }

  // Attach the policy granting the 's3:ListAllMyBuckets' action to the role.
  await iamClient.send(
    new AttachRolePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
      RoleName: Role.RoleName,
    }),
  );

  // Assume the role.
  const stsClient = new STSClient({
    credentials: {
      accessKeyId: AccessKeyId,
      secretAccessKey: SecretAccessKey,
    },
  });

  // Retry the assume role operation until it succeeds.
  const { Credentials } = await retry(
    { intervalInMs: 2000, maxRetries: 60 },
    () =>
      stsClient.send(
        new AssumeRoleCommand({
          RoleArn: Role.Arn,
          RoleSessionName: `iamBasicScenarioSession-${Math.floor(
            Math.random() * 1000000,
          )}`,
          DurationSeconds: 900,
        }),
      ),
  );

  if (!Credentials?.AccessKeyId || !Credentials?.SecretAccessKey) {
    throw new Error("Credentials not created");
  }

  s3Client = new S3Client({
    credentials: {
      accessKeyId: Credentials.AccessKeyId,
      secretAccessKey: Credentials.SecretAccessKey,
      sessionToken: Credentials.SessionToken,
    },
  });

  // List the S3 buckets again.
  // Retry the list buckets operation until it succeeds. AccessDenied might
  // be thrown while the role policy is still stabilizing.
  await retry({ intervalInMs: 2000, maxRetries: 120 }, () =>
    listBuckets(s3Client),
  );

  // Clean up.
  await iamClient.send(
    new DetachRolePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
      RoleName: Role.RoleName,
    }),
  );

  await iamClient.send(
    new DeletePolicyCommand({
      PolicyArn: listBucketPolicy.Arn,
    }),
  );

  await iamClient.send(
    new DeleteRoleCommand({
      RoleName: Role.RoleName,
    }),
  );

  await iamClient.send(
    new DeleteAccessKeyCommand({
      UserName: userName,
      AccessKeyId,
    }),
  );

  await iamClient.send(
    new DeleteUserCommand({
      UserName: userName,
    }),
  );
};

/**
 *
 * @param {S3Client} s3Client
 */
const listBuckets = async (s3Client) => {
  const { Buckets } = await s3Client.send(new ListBucketsCommand({}));

  if (!Buckets) {
    throw new Error("Buckets not listed");
  }

  console.log(Buckets.map((bucket) => bucket.Name).join("\n"));
};
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für JavaScript -API-Referenz*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/AttachRolePolicyCommand)
  + [CreateAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateAccessKeyCommand)
  + [CreatePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreatePolicyCommand)
  + [CreateRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateRoleCommand)
  + [CreateUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateUserCommand)
  + [DeleteAccessKey](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteAccessKeyCommand)
  + [DeletePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeletePolicyCommand)
  + [DeleteRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteRoleCommand)
  + [DeleteUser](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserCommand)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DeleteUserPolicyCommand)
  + [DetachRolePolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/DetachRolePolicyCommand)
  + [PutUserPolicy](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/PutUserPolicyCommand)

------
#### [ Kotlin ]

**SDK für Kotlin**  
 Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/iam#code-examples) einrichten und ausführen. 
Erstellen Sie Funktionen, die IAM-Benutzer-Aktionen umschließen.  

```
suspend fun main(args: Array<String>) {
    val usage = """
    Usage:
        <username> <policyName> <roleName> <roleSessionName> <fileLocation> <bucketName> 

    Where:
        username - The name of the IAM user to create. 
        policyName - The name of the policy to create. 
        roleName - The name of the role to create. 
        roleSessionName - The name of the session required for the assumeRole operation. 
        fileLocation - The file location to the JSON required to create the role (see Readme). 
        bucketName - The name of the Amazon S3 bucket from which objects are read. 
    """

    if (args.size != 6) {
        println(usage)
        exitProcess(1)
    }

    val userName = args[0]
    val policyName = args[1]
    val roleName = args[2]
    val roleSessionName = args[3]
    val fileLocation = args[4]
    val bucketName = args[5]

    createUser(userName)
    println("$userName was successfully created.")

    val polArn = createPolicy(policyName)
    println("The policy $polArn was successfully created.")

    val roleArn = createRole(roleName, fileLocation)
    println("$roleArn was successfully created.")
    attachRolePolicy(roleName, polArn)

    println("*** Wait for 1 MIN so the resource is available.")
    delay(60000)
    assumeGivenRole(roleArn, roleSessionName, bucketName)

    println("*** Getting ready to delete the AWS resources.")
    deleteRole(roleName, polArn)
    deleteUser(userName)
    println("This IAM Scenario has successfully completed.")
}

suspend fun createUser(usernameVal: String?): String? {
    val request =
        CreateUserRequest {
            userName = usernameVal
        }

    IamClient { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createUser(request)
        return response.user?.userName
    }
}

suspend fun createPolicy(policyNameVal: String?): String {
    val policyDocumentValue = """
    {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "s3:*"
                ],
                "Resource": "*"
            }
        ]
    }
    """.trimIndent()

    val request =
        CreatePolicyRequest {
            policyName = policyNameVal
            policyDocument = policyDocumentValue
        }

    IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createPolicy(request)
        return response.policy?.arn.toString()
    }
}

suspend fun createRole(
    rolenameVal: String?,
    fileLocation: String?,
): String? {
    val jsonObject = fileLocation?.let { readJsonSimpleDemo(it) } as JSONObject

    val request =
        CreateRoleRequest {
            roleName = rolenameVal
            assumeRolePolicyDocument = jsonObject.toJSONString()
            description = "Created using the AWS SDK for Kotlin"
        }

    IamClient { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.createRole(request)
        return response.role?.arn
    }
}

suspend fun attachRolePolicy(
    roleNameVal: String,
    policyArnVal: String,
) {
    val request =
        ListAttachedRolePoliciesRequest {
            roleName = roleNameVal
        }

    IamClient.fromEnvironment { region = "AWS_GLOBAL" }.use { iamClient ->
        val response = iamClient.listAttachedRolePolicies(request)
        val attachedPolicies = response.attachedPolicies

        // Ensure that the policy is not attached to this role.
        val checkStatus: Int
        if (attachedPolicies != null) {
            checkStatus = checkMyList(attachedPolicies, policyArnVal)
            if (checkStatus == -1) {
                return
            }
        }

        val policyRequest =
            AttachRolePolicyRequest {
                roleName = roleNameVal
                policyArn = policyArnVal
            }
        iamClient.attachRolePolicy(policyRequest)
        println("Successfully attached policy $policyArnVal to role $roleNameVal")
    }
}

fun checkMyList(
    attachedPolicies: List<AttachedPolicy>,
    policyArnVal: String,
): Int {
    for (policy in attachedPolicies) {
        val polArn = policy.policyArn.toString()

        if (polArn.compareTo(policyArnVal) == 0) {
            println("The policy is already attached to this role.")
            return -1
        }
    }
    return 0
}

suspend fun assumeGivenRole(
    roleArnVal: String?,
    roleSessionNameVal: String?,
    bucketName: String,
) {
    val stsClient = StsClient.fromEnvironment { region = "us-east-1" }
    val roleRequest =
        AssumeRoleRequest {
            roleArn = roleArnVal
            roleSessionName = roleSessionNameVal
        }

    val roleResponse = stsClient.assumeRole(roleRequest)
    val myCreds = roleResponse.credentials
    val key = myCreds?.accessKeyId
    val secKey = myCreds?.secretAccessKey
    val secToken = myCreds?.sessionToken

    val staticCredentials = StaticCredentialsProvider {
        accessKeyId = key
        secretAccessKey = secKey
        sessionToken = secToken
    }

    // List all objects in an Amazon S3 bucket using the temp creds.
    val s3 = S3Client.fromEnvironment {
        region = "us-east-1"
        credentialsProvider = staticCredentials
    }

    println("Created a S3Client using temp credentials.")
    println("Listing objects in $bucketName")

    val listObjects =
        ListObjectsRequest {
            bucket = bucketName
        }

    val response = s3.listObjects(listObjects)
    response.contents?.forEach { myObject ->
        println("The name of the key is ${myObject.key}")
        println("The owner is ${myObject.owner}")
    }
}

suspend fun deleteRole(
    roleNameVal: String,
    polArn: String,
) {
    val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" }

    // First the policy needs to be detached.
    val rolePolicyRequest =
        DetachRolePolicyRequest {
            policyArn = polArn
            roleName = roleNameVal
        }

    iam.detachRolePolicy(rolePolicyRequest)

    // Delete the policy.
    val request =
        DeletePolicyRequest {
            policyArn = polArn
        }

    iam.deletePolicy(request)
    println("*** Successfully deleted $polArn")

    // Delete the role.
    val roleRequest =
        DeleteRoleRequest {
            roleName = roleNameVal
        }

    iam.deleteRole(roleRequest)
    println("*** Successfully deleted $roleNameVal")
}

suspend fun deleteUser(userNameVal: String) {
    val iam = IamClient.fromEnvironment { region = "AWS_GLOBAL" }
    val request =
        DeleteUserRequest {
            userName = userNameVal
        }

    iam.deleteUser(request)
    println("*** Successfully deleted $userNameVal")
}

@Throws(java.lang.Exception::class)
fun readJsonSimpleDemo(filename: String): Any? {
    val reader = FileReader(filename)
    val jsonParser = JSONParser()
    return jsonParser.parse(reader)
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS -SDK für Kotlin*.
  + [AttachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreatePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [CreateUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteAccessKey](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeletePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteRole](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteUser](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DeleteUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [DetachRolePolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)
  + [PutUserPolicy](https://sdk.amazonaws.com/kotlin/api/latest/index.html)

------
#### [ PHP ]

**SDK für PHP**  
 Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/iam#code-examples) einrichten und ausführen. 

```
namespace Iam\Basics;

require 'vendor/autoload.php';

use Aws\Credentials\Credentials;
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
use Iam\IAMService;

echo("\n");
echo("--------------------------------------\n");
print("Welcome to the IAM getting started demo using PHP!\n");
echo("--------------------------------------\n");

$uuid = uniqid();
$service = new IAMService();

$user = $service->createUser("iam_demo_user_$uuid");
echo "Created user with the arn: {$user['Arn']}\n";

$key = $service->createAccessKey($user['UserName']);
$assumeRolePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{$user['Arn']}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";

$listAllBucketsPolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]
}";
$listAllBucketsPolicy = $service->createPolicy("iam_demo_policy_$uuid", $listAllBucketsPolicyDocument);
echo "Created policy: {$listAllBucketsPolicy['PolicyName']}\n";

$service->attachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);

$inlinePolicyDocument = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"{$assumeRoleRole['Arn']}\"}]
}";
$inlinePolicy = $service->createUserPolicy("iam_demo_inline_policy_$uuid", $inlinePolicyDocument, $user['UserName']);
//First, fail to list the buckets with the user
$credentials = new Credentials($key['AccessKeyId'], $key['SecretAccessKey']);
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
try {
    $s3Client->listBuckets([
    ]);
    echo "this should not run";
} catch (S3Exception $exception) {
    echo "successfully failed!\n";
}

$stsClient = new StsClient(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
sleep(10);
$assumedRole = $stsClient->assumeRole([
    'RoleArn' => $assumeRoleRole['Arn'],
    'RoleSessionName' => "DemoAssumeRoleSession_$uuid",
]);
$assumedCredentials = [
    'key' => $assumedRole['Credentials']['AccessKeyId'],
    'secret' => $assumedRole['Credentials']['SecretAccessKey'],
    'token' => $assumedRole['Credentials']['SessionToken'],
];
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $assumedCredentials]);
try {
    $s3Client->listBuckets([]);
    echo "this should now run!\n";
} catch (S3Exception $exception) {
    echo "this should now not fail\n";
}

$service->detachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);
$deletePolicy = $service->deletePolicy($listAllBucketsPolicy['Arn']);
echo "Delete policy: {$listAllBucketsPolicy['PolicyName']}\n";
$deletedRole = $service->deleteRole($assumeRoleRole['Arn']);
echo "Deleted role: {$assumeRoleRole['RoleName']}\n";
$deletedKey = $service->deleteAccessKey($key['AccessKeyId'], $user['UserName']);
$deletedUser = $service->deleteUser($user['UserName']);
echo "Delete user: {$user['UserName']}\n";
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für PHP -API-Referenz*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Python ]

**SDK für Python (Boto3)**  
 Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/iam#code-examples) einrichten und ausführen. 
Erstellen Sie einen IAM-Benutzer und eine Rolle, die die Berechtigung zum Auflisten von Amazon-S3-Buckets erteilt. Der Benutzer hat nur Rechte, um die Rolle anzunehmen. Nachdem Sie die Rolle übernommen haben, verwenden Sie temporäre Anmeldeinformationen, um Buckets für das Konto aufzulisten.  

```
import json
import sys
import time
from uuid import uuid4

import boto3
from botocore.exceptions import ClientError


def progress_bar(seconds):
    """Shows a simple progress bar in the command window."""
    for _ in range(seconds):
        time.sleep(1)
        print(".", end="")
        sys.stdout.flush()
    print()


def setup(iam_resource):
    """
    Creates a new user with no permissions.
    Creates an access key pair for the user.
    Creates a role with a policy that lets the user assume the role.
    Creates a policy that allows listing Amazon S3 buckets.
    Attaches the policy to the role.
    Creates an inline policy for the user that lets the user assume the role.

    :param iam_resource: A Boto3 AWS Identity and Access Management (IAM) resource
                         that has permissions to create users, roles, and policies
                         in the account.
    :return: The newly created user, user key, and role.
    """
    try:
        user = iam_resource.create_user(UserName=f"demo-user-{uuid4()}")
        print(f"Created user {user.name}.")
    except ClientError as error:
        print(
            f"Couldn't create a user for the demo. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        user_key = user.create_access_key_pair()
        print(f"Created access key pair for user.")
    except ClientError as error:
        print(
            f"Couldn't create access keys for user {user.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    print(f"Wait for user to be ready.", end="")
    progress_bar(10)

    try:
        role = iam_resource.create_role(
            RoleName=f"demo-role-{uuid4()}",
            AssumeRolePolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {"AWS": user.arn},
                            "Action": "sts:AssumeRole",
                        }
                    ],
                }
            ),
        )
        print(f"Created role {role.name}.")
    except ClientError as error:
        print(
            f"Couldn't create a role for the demo. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        policy = iam_resource.create_policy(
            PolicyName=f"demo-policy-{uuid4()}",
            PolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "s3:ListAllMyBuckets",
                            "Resource": "arn:aws:s3:::*",
                        }
                    ],
                }
            ),
        )
        role.attach_policy(PolicyArn=policy.arn)
        print(f"Created policy {policy.policy_name} and attached it to the role.")
    except ClientError as error:
        print(
            f"Couldn't create a policy and attach it to role {role.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        user.create_policy(
            PolicyName=f"demo-user-policy-{uuid4()}",
            PolicyDocument=json.dumps(
                {
                    "Version":"2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "sts:AssumeRole",
                            "Resource": role.arn,
                        }
                    ],
                }
            ),
        )
        print(
            f"Created an inline policy for {user.name} that lets the user assume "
            f"the role."
        )
    except ClientError as error:
        print(
            f"Couldn't create an inline policy for user {user.name}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    print("Give AWS time to propagate these new resources and connections.", end="")
    progress_bar(10)

    return user, user_key, role


def show_access_denied_without_role(user_key):
    """
    Shows that listing buckets without first assuming the role is not allowed.

    :param user_key: The key of the user created during setup. This user does not
                     have permission to list buckets in the account.
    """
    print(f"Try to list buckets without first assuming the role.")
    s3_denied_resource = boto3.resource(
        "s3", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret
    )
    try:
        for bucket in s3_denied_resource.buckets.all():
            print(bucket.name)
        raise RuntimeError("Expected to get AccessDenied error when listing buckets!")
    except ClientError as error:
        if error.response["Error"]["Code"] == "AccessDenied":
            print("Attempt to list buckets with no permissions: AccessDenied.")
        else:
            raise


def list_buckets_from_assumed_role(user_key, assume_role_arn, session_name):
    """
    Assumes a role that grants permission to list the Amazon S3 buckets in the account.
    Uses the temporary credentials from the role to list the buckets that are owned
    by the assumed role's account.

    :param user_key: The access key of a user that has permission to assume the role.
    :param assume_role_arn: The Amazon Resource Name (ARN) of the role that
                            grants access to list the other account's buckets.
    :param session_name: The name of the STS session.
    """
    sts_client = boto3.client(
        "sts", aws_access_key_id=user_key.id, aws_secret_access_key=user_key.secret
    )
    try:
        response = sts_client.assume_role(
            RoleArn=assume_role_arn, RoleSessionName=session_name
        )
        temp_credentials = response["Credentials"]
        print(f"Assumed role {assume_role_arn} and got temporary credentials.")
    except ClientError as error:
        print(
            f"Couldn't assume role {assume_role_arn}. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    # Create an S3 resource that can access the account with the temporary credentials.
    s3_resource = boto3.resource(
        "s3",
        aws_access_key_id=temp_credentials["AccessKeyId"],
        aws_secret_access_key=temp_credentials["SecretAccessKey"],
        aws_session_token=temp_credentials["SessionToken"],
    )
    print(f"Listing buckets for the assumed role's account:")
    try:
        for bucket in s3_resource.buckets.all():
            print(bucket.name)
    except ClientError as error:
        print(
            f"Couldn't list buckets for the account. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise




def teardown(user, role):
    """
    Removes all resources created during setup.

    :param user: The demo user.
    :param role: The demo role.
    """
    try:
        for attached in role.attached_policies.all():
            policy_name = attached.policy_name
            role.detach_policy(PolicyArn=attached.arn)
            attached.delete()
            print(f"Detached and deleted {policy_name}.")
        role.delete()
        print(f"Deleted {role.name}.")
    except ClientError as error:
        print(
            "Couldn't detach policy, delete policy, or delete role. Here's why: "
            f"{error.response['Error']['Message']}"
        )
        raise

    try:
        for user_pol in user.policies.all():
            user_pol.delete()
            print("Deleted inline user policy.")
        for key in user.access_keys.all():
            key.delete()
            print("Deleted user's access key.")
        user.delete()
        print(f"Deleted {user.name}.")
    except ClientError as error:
        print(
            "Couldn't delete user policy or delete user. Here's why: "
            f"{error.response['Error']['Message']}"
        )


def usage_demo():
    """Drives the demonstration."""
    print("-" * 88)
    print(f"Welcome to the IAM create user and assume role demo.")
    print("-" * 88)
    iam_resource = boto3.resource("iam")
    user = None
    role = None
    try:
        user, user_key, role = setup(iam_resource)
        print(f"Created {user.name} and {role.name}.")
        show_access_denied_without_role(user_key)
        list_buckets_from_assumed_role(user_key, role.arn, "AssumeRoleDemoSession")
    except Exception:
        print("Something went wrong!")
    finally:
        if user is not None and role is not None:
            teardown(user, role)
        print("Thanks for watching!")


if __name__ == "__main__":
    usage_demo()
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für Python (Boto3)*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/PutUserPolicy)

------
#### [ Ruby ]

**SDK für Ruby**  
 Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/iam#code-examples) einrichten und ausführen. 
Erstellen Sie einen IAM-Benutzer und eine Rolle, die die Berechtigung zum Auflisten von Amazon-S3-Buckets erteilt. Der Benutzer hat nur Rechte, um die Rolle anzunehmen. Nachdem Sie die Rolle übernommen haben, verwenden Sie temporäre Anmeldeinformationen, um Buckets für das Konto aufzulisten.  

```
# Wraps the scenario actions.
class ScenarioCreateUserAssumeRole
  attr_reader :iam_client

  # @param [Aws::IAM::Client] iam_client: The AWS IAM client.
  def initialize(iam_client, logger: Logger.new($stdout))
    @iam_client = iam_client
    @logger = logger
  end

  # Waits for the specified number of seconds.
  #
  # @param duration [Integer] The number of seconds to wait.
  def wait(duration)
    puts('Give AWS time to propagate resources...')
    sleep(duration)
  end

  # Creates a user.
  #
  # @param user_name [String] The name to give the user.
  # @return [Aws::IAM::User] The newly created user.
  def create_user(user_name)
    user = @iam_client.create_user(user_name: user_name).user
    @logger.info("Created demo user named #{user.user_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info('Tried and failed to create demo user.')
    @logger.info("\t#{e.code}: #{e.message}")
    @logger.info("\nCan't continue the demo without a user!")
    raise
  else
    user
  end

  # Creates an access key for a user.
  #
  # @param user [Aws::IAM::User] The user that owns the key.
  # @return [Aws::IAM::AccessKeyPair] The newly created access key.
  def create_access_key_pair(user)
    user_key = @iam_client.create_access_key(user_name: user.user_name).access_key
    @logger.info("Created accesskey pair for user #{user.user_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create access keys for user #{user.user_name}.")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  else
    user_key
  end

  # Creates a role that can be assumed by a user.
  #
  # @param role_name [String] The name to give the role.
  # @param user [Aws::IAM::User] The user who is granted permission to assume the role.
  # @return [Aws::IAM::Role] The newly created role.
  def create_role(role_name, user)
    trust_policy = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Principal: { 'AWS': user.arn },
        Action: 'sts:AssumeRole'
      }]
    }.to_json
    role = @iam_client.create_role(
      role_name: role_name,
      assume_role_policy_document: trust_policy
    ).role
    @logger.info("Created role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create a role for the demo. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  else
    role
  end

  # Creates a policy that grants permission to list S3 buckets in the account, and
  # then attaches the policy to a role.
  #
  # @param policy_name [String] The name to give the policy.
  # @param role [Aws::IAM::Role] The role that the policy is attached to.
  # @return [Aws::IAM::Policy] The newly created policy.
  def create_and_attach_role_policy(policy_name, role)
    policy_document = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Action: 's3:ListAllMyBuckets',
        Resource: 'arn:aws:s3:::*'
      }]
    }.to_json
    policy = @iam_client.create_policy(
      policy_name: policy_name,
      policy_document: policy_document
    ).policy
    @iam_client.attach_role_policy(
      role_name: role.role_name,
      policy_arn: policy.arn
    )
    @logger.info("Created policy #{policy.policy_name} and attached it to role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create a policy and attach it to role #{role.role_name}. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Creates an inline policy for a user that lets the user assume a role.
  #
  # @param policy_name [String] The name to give the policy.
  # @param user [Aws::IAM::User] The user that owns the policy.
  # @param role [Aws::IAM::Role] The role that can be assumed.
  # @return [Aws::IAM::UserPolicy] The newly created policy.
  def create_user_policy(policy_name, user, role)
    policy_document = {
      Version: '2012-10-17',
      Statement: [{
        Effect: 'Allow',
        Action: 'sts:AssumeRole',
        Resource: role.arn
      }]
    }.to_json
    @iam_client.put_user_policy(
      user_name: user.user_name,
      policy_name: policy_name,
      policy_document: policy_document
    )
    puts("Created an inline policy for #{user.user_name} that lets the user assume role #{role.role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't create an inline policy for user #{user.user_name}. Here's why: ")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Creates an Amazon S3 resource with specified credentials. This is separated into a
  # factory function so that it can be mocked for unit testing.
  #
  # @param credentials [Aws::Credentials] The credentials used by the Amazon S3 resource.
  def create_s3_resource(credentials)
    Aws::S3::Resource.new(client: Aws::S3::Client.new(credentials: credentials))
  end

  # Lists the S3 buckets for the account, using the specified Amazon S3 resource.
  # Because the resource uses credentials with limited access, it may not be able to
  # list the S3 buckets.
  #
  # @param s3_resource [Aws::S3::Resource] An Amazon S3 resource.
  def list_buckets(s3_resource)
    count = 10
    s3_resource.buckets.each do |bucket|
      @logger.info "\t#{bucket.name}"
      count -= 1
      break if count.zero?
    end
  rescue Aws::Errors::ServiceError => e
    if e.code == 'AccessDenied'
      puts('Attempt to list buckets with no permissions: AccessDenied.')
    else
      @logger.info("Couldn't list buckets for the account. Here's why: ")
      @logger.info("\t#{e.code}: #{e.message}")
      raise
    end
  end

  # Creates an AWS Security Token Service (AWS STS) client with specified credentials.
  # This is separated into a factory function so that it can be mocked for unit testing.
  #
  # @param key_id [String] The ID of the access key used by the STS client.
  # @param key_secret [String] The secret part of the access key used by the STS client.
  def create_sts_client(key_id, key_secret)
    Aws::STS::Client.new(access_key_id: key_id, secret_access_key: key_secret)
  end

  # Gets temporary credentials that can be used to assume a role.
  #
  # @param role_arn [String] The ARN of the role that is assumed when these credentials
  #                          are used.
  # @param sts_client [AWS::STS::Client] An AWS STS client.
  # @return [Aws::AssumeRoleCredentials] The credentials that can be used to assume the role.
  def assume_role(role_arn, sts_client)
    credentials = Aws::AssumeRoleCredentials.new(
      client: sts_client,
      role_arn: role_arn,
      role_session_name: 'create-use-assume-role-scenario'
    )
    @logger.info("Assumed role '#{role_arn}', got temporary credentials.")
    credentials
  end

  # Deletes a role. If the role has policies attached, they are detached and
  # deleted before the role is deleted.
  #
  # @param role_name [String] The name of the role to delete.
  def delete_role(role_name)
    @iam_client.list_attached_role_policies(role_name: role_name).attached_policies.each do |policy|
      @iam_client.detach_role_policy(role_name: role_name, policy_arn: policy.policy_arn)
      @iam_client.delete_policy(policy_arn: policy.policy_arn)
      @logger.info("Detached and deleted policy #{policy.policy_name}.")
    end
    @iam_client.delete_role({ role_name: role_name })
    @logger.info("Role deleted: #{role_name}.")
  rescue Aws::Errors::ServiceError => e
    @logger.info("Couldn't detach policies and delete role #{role.name}. Here's why:")
    @logger.info("\t#{e.code}: #{e.message}")
    raise
  end

  # Deletes a user. If the user has inline policies or access keys, they are deleted
  # before the user is deleted.
  #
  # @param user [Aws::IAM::User] The user to delete.
  def delete_user(user_name)
    user = @iam_client.list_access_keys(user_name: user_name).access_key_metadata
    user.each do |key|
      @iam_client.delete_access_key({ access_key_id: key.access_key_id, user_name: user_name })
      @logger.info("Deleted access key #{key.access_key_id} for user '#{user_name}'.")
    end

    @iam_client.delete_user(user_name: user_name)
    @logger.info("Deleted user '#{user_name}'.")
  rescue Aws::IAM::Errors::ServiceError => e
    @logger.error("Error deleting user '#{user_name}': #{e.message}")
  end
end

# Runs the IAM create a user and assume a role scenario.
def run_scenario(scenario)
  puts('-' * 88)
  puts('Welcome to the IAM create a user and assume a role demo!')
  puts('-' * 88)
  user = scenario.create_user("doc-example-user-#{Random.uuid}")
  user_key = scenario.create_access_key_pair(user)
  scenario.wait(10)
  role = scenario.create_role("doc-example-role-#{Random.uuid}", user)
  scenario.create_and_attach_role_policy("doc-example-role-policy-#{Random.uuid}", role)
  scenario.create_user_policy("doc-example-user-policy-#{Random.uuid}", user, role)
  scenario.wait(10)
  puts('Try to list buckets with credentials for a user who has no permissions.')
  puts('Expect AccessDenied from this call.')
  scenario.list_buckets(
    scenario.create_s3_resource(Aws::Credentials.new(user_key.access_key_id, user_key.secret_access_key))
  )
  puts('Now, assume the role that grants permission.')
  temp_credentials = scenario.assume_role(
    role.arn, scenario.create_sts_client(user_key.access_key_id, user_key.secret_access_key)
  )
  puts('Here are your buckets:')
  scenario.list_buckets(scenario.create_s3_resource(temp_credentials))
  puts("Deleting role '#{role.role_name}' and attached policies.")
  scenario.delete_role(role.role_name)
  puts("Deleting user '#{user.user_name}', policies, and keys.")
  scenario.delete_user(user.user_name)
  puts('Thanks for watching!')
  puts('-' * 88)
rescue Aws::Errors::ServiceError => e
  puts('Something went wrong with the demo.')
  puts("\t#{e.code}: #{e.message}")
end

run_scenario(ScenarioCreateUserAssumeRole.new(Aws::IAM::Client.new)) if $PROGRAM_NAME == __FILE__
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für Ruby -API-Referenz*.
  + [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/AttachRolePolicy)
  + [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateAccessKey)
  + [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreatePolicy)
  + [CreateRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateRole)
  + [CreateUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateUser)
  + [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteAccessKey)
  + [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeletePolicy)
  + [DeleteRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteRole)
  + [DeleteUser](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUser)
  + [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DeleteUserPolicy)
  + [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/DetachRolePolicy)
  + [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/PutUserPolicy)

------
#### [ Rust ]

**SDK für Rust**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples) einrichten und ausführen. 

```
use aws_config::meta::region::RegionProviderChain;
use aws_sdk_iam::Error as iamError;
use aws_sdk_iam::{config::Credentials as iamCredentials, config::Region, Client as iamClient};
use aws_sdk_s3::Client as s3Client;
use aws_sdk_sts::Client as stsClient;
use tokio::time::{sleep, Duration};
use uuid::Uuid;

#[tokio::main]
async fn main() -> Result<(), iamError> {
    let (client, uuid, list_all_buckets_policy_document, inline_policy_document) =
        initialize_variables().await;

    if let Err(e) = run_iam_operations(
        client,
        uuid,
        list_all_buckets_policy_document,
        inline_policy_document,
    )
    .await
    {
        println!("{:?}", e);
    };

    Ok(())
}

async fn initialize_variables() -> (iamClient, String, String, String) {
    let region_provider = RegionProviderChain::first_try(Region::new("us-west-2"));

    let shared_config = aws_config::from_env().region(region_provider).load().await;
    let client = iamClient::new(&shared_config);
    let uuid = Uuid::new_v4().to_string();

    let list_all_buckets_policy_document = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"s3:ListAllMyBuckets\",
                    \"Resource\": \"arn:aws:s3:::*\"}]
    }"
    .to_string();
    let inline_policy_document = "{
                \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Action\": \"sts:AssumeRole\",
                    \"Resource\": \"{}\"}]
    }"
    .to_string();

    (
        client,
        uuid,
        list_all_buckets_policy_document,
        inline_policy_document,
    )
}

async fn run_iam_operations(
    client: iamClient,
    uuid: String,
    list_all_buckets_policy_document: String,
    inline_policy_document: String,
) -> Result<(), iamError> {
    let user = iam_service::create_user(&client, &format!("{}{}", "iam_demo_user_", uuid)).await?;
    println!("Created the user with the name: {}", user.user_name());
    let key = iam_service::create_access_key(&client, user.user_name()).await?;

    let assume_role_policy_document = "{
        \"Version\": \"2012-10-17\",
                \"Statement\": [{
                    \"Effect\": \"Allow\",
                    \"Principal\": {\"AWS\": \"{}\"},
                    \"Action\": \"sts:AssumeRole\"
                }]
            }"
    .to_string()
    .replace("{}", user.arn());

    let assume_role_role = iam_service::create_role(
        &client,
        &format!("{}{}", "iam_demo_role_", uuid),
        &assume_role_policy_document,
    )
    .await?;
    println!("Created the role with the ARN: {}", assume_role_role.arn());

    let list_all_buckets_policy = iam_service::create_policy(
        &client,
        &format!("{}{}", "iam_demo_policy_", uuid),
        &list_all_buckets_policy_document,
    )
    .await?;
    println!(
        "Created policy: {}",
        list_all_buckets_policy.policy_name.as_ref().unwrap()
    );

    let attach_role_policy_result =
        iam_service::attach_role_policy(&client, &assume_role_role, &list_all_buckets_policy)
            .await?;
    println!(
        "Attached the policy to the role: {:?}",
        attach_role_policy_result
    );

    let inline_policy_name = format!("{}{}", "iam_demo_inline_policy_", uuid);
    let inline_policy_document = inline_policy_document.replace("{}", assume_role_role.arn());
    iam_service::create_user_policy(&client, &user, &inline_policy_name, &inline_policy_document)
        .await?;
    println!("Created inline policy.");

    //First, fail to list the buckets with the user.
    let creds = iamCredentials::from_keys(key.access_key_id(), key.secret_access_key(), None);
    let fail_config = aws_config::from_env()
        .credentials_provider(creds.clone())
        .load()
        .await;
    println!("Fail config: {:?}", fail_config);
    let fail_client: s3Client = s3Client::new(&fail_config);
    match fail_client.list_buckets().send().await {
        Ok(e) => {
            println!("This should not run. {:?}", e);
        }
        Err(e) => {
            println!("Successfully failed with error: {:?}", e)
        }
    }

    let sts_config = aws_config::from_env()
        .credentials_provider(creds.clone())
        .load()
        .await;
    let sts_client: stsClient = stsClient::new(&sts_config);
    sleep(Duration::from_secs(10)).await;
    let assumed_role = sts_client
        .assume_role()
        .role_arn(assume_role_role.arn())
        .role_session_name(format!("iam_demo_assumerole_session_{uuid}"))
        .send()
        .await;
    println!("Assumed role: {:?}", assumed_role);
    sleep(Duration::from_secs(10)).await;

    let assumed_credentials = iamCredentials::from_keys(
        assumed_role
            .as_ref()
            .unwrap()
            .credentials
            .as_ref()
            .unwrap()
            .access_key_id(),
        assumed_role
            .as_ref()
            .unwrap()
            .credentials
            .as_ref()
            .unwrap()
            .secret_access_key(),
        Some(
            assumed_role
                .as_ref()
                .unwrap()
                .credentials
                .as_ref()
                .unwrap()
                .session_token
                .clone(),
        ),
    );

    let succeed_config = aws_config::from_env()
        .credentials_provider(assumed_credentials)
        .load()
        .await;
    println!("succeed config: {:?}", succeed_config);
    let succeed_client: s3Client = s3Client::new(&succeed_config);
    sleep(Duration::from_secs(10)).await;
    match succeed_client.list_buckets().send().await {
        Ok(_) => {
            println!("This should now run successfully.")
        }
        Err(e) => {
            println!("This should not run. {:?}", e);
            panic!()
        }
    }

    //Clean up.
    iam_service::detach_role_policy(
        &client,
        assume_role_role.role_name(),
        list_all_buckets_policy.arn().unwrap_or_default(),
    )
    .await?;
    iam_service::delete_policy(&client, list_all_buckets_policy).await?;
    iam_service::delete_role(&client, &assume_role_role).await?;
    println!("Deleted role {}", assume_role_role.role_name());
    iam_service::delete_access_key(&client, &user, &key).await?;
    println!("Deleted key for {}", key.user_name());
    iam_service::delete_user_policy(&client, &user, &inline_policy_name).await?;
    println!("Deleted inline user policy: {}", inline_policy_name);
    iam_service::delete_user(&client, &user).await?;
    println!("Deleted user {}", user.user_name());

    Ok(())
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS -SDK für Rust*.
  + [AttachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.attach_role_policy)
  + [CreateAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_access_key)
  + [CreatePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_policy)
  + [CreateRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_role)
  + [CreateUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_user)
  + [DeleteAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_access_key)
  + [DeletePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_policy)
  + [DeleteRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_role)
  + [DeleteUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user)
  + [DeleteUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user_policy)
  + [DetachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.detach_role_policy)
  + [PutUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.put_user_policy)

------

# Verwendung einer IAM-Rolle zur Gewährung von Berechtigungen für Anwendungen, die in Amazon-EC2-Instances ausgeführt werden
<a name="id_roles_use_switch-role-ec2"></a>

Anwendungen, die auf einer Amazon EC2 EC2-Instance ausgeführt werden, müssen AWS Anmeldeinformationen in den AWS API-Anfragen enthalten. Sie könnten Ihre Entwickler AWS Anmeldeinformationen direkt in der Amazon EC2 EC2-Instance speichern lassen und Anwendungen in dieser Instance erlauben, diese Anmeldeinformationen zu verwenden. Allerdings müssten Entwickler dann die Anmeldeinformationen verwalten und sicherstellen, dass sie die Anmeldeinformationen sicher an jede Instance weitergeben und jede Amazon-EC2-Instance aktualisieren, wenn es Zeit für die Aktualisierung der Anmeldeinformationen ist. Das ist eine Menge zusätzlicher Arbeit.

Stattdessen können und sollten Sie eine IAM-Rolle verwenden, um *temporäre* Anmeldeinformationen für Anwendungen zu verwalten, die auf einer Amazon-EC2-Instance ausgeführt werden. Wenn Sie eine Rolle verwenden, müssen Sie keine langfristigen Anmeldeinformationen (wie Benutzername und Passwort oder Zugriffsschlüssel) an eine Amazon-EC2-Instance verteilen. Stattdessen stellt die Rolle temporäre Berechtigungen bereit, die Anwendungen verwenden können, wenn sie andere AWS Ressourcen aufrufen. Wenn Sie eine Amazon EC2-Instance starten, geben Sie eine mit der Instance zu verknüpfende IAM-Rolle an. Anwendungen, die auf der Instance ausgeführt werden, können dann die von der Rolle bereitgestellten temporären Anmeldeinformationen für API-Anforderungen verwenden.

Die Verwendung von Rollen zur Erteilung von Berechtigungen für Anwendungen, die auf Amazon-EC2-Instances ausgeführt werden, erfordert etwas mehr Konfigurationsaufwand. Eine Anwendung, die auf einer Amazon EC2 EC2-Instance ausgeführt wird, wird AWS vom virtualisierten Betriebssystem abstrahiert. Aufgrund dieser zusätzlichen Trennung benötigen Sie einen zusätzlichen Schritt, um einer Amazon EC2 EC2-Instance eine AWS Rolle und die zugehörigen Berechtigungen zuzuweisen und sie für ihre Anwendungen verfügbar zu machen. Dieser zusätzliche Schritt ist die Erstellung eines *[Instance-Profils](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html)*, das einer Instance angefügt wird. Das Instance-Profil enthält die Rolle und kann einer auf einer Instance ausgeführten Anwendung die temporären Anmeldeinformationen der Rolle zur Verfügung stellen. Diese temporären Anmeldeinformationen können dann für die API-Aufrufe der Anwendung verwendet werden, um auf Ressourcen zuzugreifen und den Zugriff auf die in der Rolle angegebenen Ressourcen zu beschränken.

**Anmerkung**  
Einer Amazon-EC2-Instance kann jeweils nur eine Rolle zugewiesen werden und alle Anwendungen auf der Instance haben dieselbe Rolle und dieselben Berechtigungen. Wenn Sie Amazon ECS zur Verwaltung Ihrer Amazon-EC2-Instances nutzen, können Sie Amazon-ECS-Aufgaben Rollen zuweisen, die sich von der Rolle der Amazon-EC2-Instance unterscheiden lassen, auf der sie ausgeführt werden. Die Zuweisung einer Rolle für jede Aufgabe entspricht dem Prinzip des Zugriffs mit der geringsten Berechtigung und ermöglicht eine differenzierte Kontrolle über Aktionen und Ressourcen.  
Weitere Informationen finden Sie unter [Verwenden von IAM-Rollen mit Amazon-ECS-Aufgaben](https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/security-iam-roles.html) im *Handbuch zu bewährten Methoden zu Amazon Elastic Container Service*.

Diese Verwendungsweise von Rollen hat mehrere Vorteile. Da Rollenanmeldeinformationen temporär sind und automatisch aktualisiert werden, müssen Sie die Anmeldeinformationen nicht verwalten und sich keine Sorgen über langfristige Sicherheitsrisiken machen. Wenn Sie darüber hinaus eine einzelne Rolle für mehrere Instances verwenden, werden alle Änderungen in dieser Rolle automatisch an alle Instances propagiert. 

**Anmerkung**  
Obwohl eine Rolle normalerweise einer Amazon-EC2-Instance zugewiesen wird, wenn Sie sie starten, kann eine Rolle auch einer Amazon-EC2-Instance angehängt werden, diese gerade ausgeführt wird. Weitere Informationen zum Anfügen einer Rolle an eine ausgeführte Instance erhalten Sie unter [IAM-Rollen für Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).

**Topics**
+ [Wie funktionieren Rollen für Amazon-EC2-Instances?](#roles-usingrole-ec2instance-roles)
+ [Erforderliche Berechtigungen für die Nutzung von Rollen mit Amazon EC2](#roles-usingrole-ec2instance-permissions)
+ [Was sind die ersten Schritte?](#roles-usingrole-ec2instance-get-started)
+ [Ähnliche Informationen](#roles-usingrole-ec2instance-related-info)

## Wie funktionieren Rollen für Amazon-EC2-Instances?
<a name="roles-usingrole-ec2instance-roles"></a>

In der folgenden Abbildung führt ein Entwickler eine Anwendung auf einer Amazon-EC2-Instance aus, die Zugriff auf den S3-Bucket namens `amzn-s3-demo-bucket-photos` benötigt. Ein Administrator erstellt die Servicerolle `Get-pics` und weist die Rolle der Amazon-EC2-Instance zu. Die Rolle enthält eine Berechtigungsrichtlinie, die Lesezugriff auf den angegebenen S3-Bucket gewährt. Sie enthält auch eine Vertrauensrichtlinie, die es der Amazon-EC2-Instance ermöglicht, die Rolle zu übernehmen und die temporären Anmeldeinformationen abzurufen. Wenn die Anwendung auf der Instance ausgeführt wird, kann sie mithilfe der temporären Anmeldeinformationen der Rolle auf den photos-Bucket zugreifen. Der Administrator muss dem Entwickler keine Berechtigung für den Zugriff auf den photos-Bucket gewähren und der Entwickler muss die Anmeldeinformationen nie weitergeben oder verwalten.

![\[Anwendung auf einer Amazon EC2 EC2-Instance, die auf eine AWS Ressource zugreift\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/roles-usingrole-ec2roleinstance.png)


1. Der Administrator erstellt mit IAM die Rolle **Get-pics**. In der Vertrauensrichtlinie der Rolle legt der Administrator fest, dass nur Amazon-EC2-Instances die Rolle übernehmen können. In der Berechtigungsrichtlinie der Rolle gibt der Administrator Leseberechtigungen für den Bucket `amzn-s3-demo-bucket-photos` an.

1. Ein Entwickler startet eine Amazon-EC2-Instance und weist die Rolle `Get-pics` dieser Instance zu.
**Anmerkung**  
Wenn Sie die IAM-Konsole verwenden, wird das Instance-Profil für Sie verwaltet und ist Ihnen gegenüber weitestgehend transparent. Wenn Sie jedoch die API AWS CLI oder verwenden, um die Rolle und die Amazon EC2 EC2-Instance zu erstellen und zu verwalten, müssen Sie das Instance-Profil erstellen und ihm die Rolle in separaten Schritten zuweisen. In diesem Fall müssen Sie den Instance-Profilnamen anstelle des Rollennamens angeben, wenn Sie die Instance starten.

1. Wenn die Anwendung ausgeführt wird, erhält sie temporäre Sicherheitsanmeldeinformationen von den Amazon EC2-[Instance-Metadaten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html), wie unter [Abrufen von Sicherheitsanmeldeinformationen von Instance-Metadaten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials) beschrieben. Hierbei handelt es sich um [temporäre Sicherheitsanmeldeinformationen](id_credentials_temp.md) für die Rolle, die für einen begrenzten Zeitraum gültig sind. 

   Bei einigen kann der Entwickler einen Anbieter verwenden [AWS SDKs](https://aws.amazon.com/tools/), der die temporären Sicherheitsanmeldedaten transparent verwaltet. (In der Dokumentation für Einzelpersonen werden die Funktionen AWS SDKs beschrieben, die von diesem SDK für die Verwaltung von Anmeldeinformationen unterstützt werden.)

   Alternativ kann die Anwendung die temporären Anmeldeinformationen auch direkt aus den Instance-Metadaten der Amazon-EC2-Instance beziehen. Die Anmeldeinformationen und die zugehörigen Werte sind in der Kategorie `iam/security-credentials/role-name` (in diesem Fall `iam/security-credentials/Get-pics`) der Metadaten verfügbar. Wenn die Anwendung die Anmeldeinformationen aus den Instance-Metadaten bezieht, können die Anmeldeinformationen zwischengespeichert werden.

1. Mithilfe der erhaltenen temporären Anmeldeinformationen greift die Anwendung auf den Bucket "photos" zu. Aufgrund der zur Rolle **Get-pics** angefügten Richtlinie verfügt die Anwendung nur über Leseberechtigungen. 

   Die in der Instance verfügbaren temporären Sicherheitsanmeldeinformationen werden vor deren Ablauf automatisch aktualisiert, sodass immer gültige Anmeldeinformationen verfügbar sind. Die Anwendung muss lediglich sicherstellen, dass sie neue Anmeldeinformationen von den Instance-Metadaten erhält, bevor die aktuellen Anmeldeinformationen ablaufen. Es ist möglich, das AWS SDK zur Verwaltung von Anmeldeinformationen zu verwenden, sodass die Anwendung keine zusätzliche Logik zum Aktualisieren der Anmeldeinformationen enthalten muss. Zum Beispiel das Instanceiieren von Clients mit Anbietern von Anmeldeinformationen für Instance-Profile. Erhält jedoch die Anwendung temporäre Anmeldeinformationen von den Instance-Metadaten und speichert diese im Cache, sollte die Anwendung die Anmeldeinformationen stündlich oder mindestens 15 Minuten vor deren Ablauf aktualisieren. Die Ablaufzeit ist in den Informationen enthalten, die in der Kategorie `iam/security-credentials/role-name` zurückgegeben wird. 

## Erforderliche Berechtigungen für die Nutzung von Rollen mit Amazon EC2
<a name="roles-usingrole-ec2instance-permissions"></a>

Um eine Instance mit einer Rolle zu starten, muss der Entwickler über die Berechtigung zum Starten von Amazon-EC2-Instances und die Berechtigung zum Übergeben von IAM-Rollen verfügen.

Mit der folgenden Beispielrichtlinie können Benutzer die verwenden AWS-Managementkonsole , um eine Instanz mit einer Rolle zu starten. Die Richtlinie enthält Platzhalter (`*`), um einem Benutzer die Übergabe von beliebigen Rollen und die Ausführung beliebiger Amazon-EC2-Aktionen zu gestatten. Die `ListInstanceProfiles`-Aktion ermöglicht den Benutzern, alle im AWS-Konto verfügbaren Rollen anzuzeigen.

**Example Beispielrichtlinie, mit der eine Benutzerberechtigung zum Starten einer Instance mit einer beliebigen Rolle über die Amazon EC2-Konsole erteilt wird**    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "IamPassRole",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "ec2.amazonaws.com"
                }
            }
        },
        {
            "Sid": "ListEc2AndListInstanceProfiles",
            "Effect": "Allow",
            "Action": [
                "iam:ListInstanceProfiles",
                "ec2:Describe*",
                "ec2:Search*",
                "ec2:Get*"
            ],
            "Resource": "*"
        }
    ]
}
```

### Einschränken, welche Rollen an Amazon EC2 EC2-Instances übergeben werden können (mit) PassRole
<a name="roles-usingrole-ec2instance-passrole"></a>

Sie können die `PassRole`-Berechtigung verwenden, um einzuschränken, welche Rolle ein Benutzer an eine Amazon-EC2-Instance übergeben kann, wenn der Benutzer die Instance startet. Dadurch können Sie verhindern, dass ein Benutzer Anwendungen ausführt, die über mehr Berechtigungen als der Benutzer verfügen, das heißt, um zu vermeiden, dass der Benutzer erhöhte Berechtigungen erhält. Angenommen, die Benutzerin Alice verfügt nur über Berechtigungen zum Starten von Amazon-EC2-Instances und für den Zugriff auf Amazon-S3-Buckets, aber die von ihr an eine Amazon-EC2-Instance übergeben Rolle verfügt über Zugriffsberechtigungen auf IAM und Amazon DynamoDB. In diesem Fall könnte Alice in der Lage sein, die Instance zu starten, sich bei ihr anzumelden, temporäre Sicherheitsanmeldeinformationen zu erhalten und dann IAM- oder DynamoDB-Aktionen durchzuführen, für die sie nicht autorisiert ist.

Um einzuschränken, welche Rollen ein Benutzer an eine Amazon-EC2-Instance übergeben kann, erstellen Sie eine Richtlinie, die die Aktion `PassRole` zulässt. Anschließend fügen Sie die Richtlinie dem Benutzer (oder einer IAM-Gruppe, zu der der Benutzer gehört) zu, der Amazon-EC2-Instances starten wird. Im Element `Resource` der Richtlinie führen Sie die Rolle oder Rollen auf, die der Benutzer an Amazon-EC2-Instances übergeben darf. Wenn der Benutzer eine Instance startet und ihr ein Rolle zuordnet, prüft Amazon EC2, ob der Benutzer zum Übergeben dieser Rolle berechtigt ist. Selbstverständlich sollten Sie auch sicherstellen, dass die Rolle, die der Benutzer übergeben darf, nicht mehr Berechtigungen enthält, als für den Benutzer vorgesehen ist.

**Anmerkung**  
`PassRole` ist keine API-Aktion im Sinne von `RunInstances` oder `ListInstanceProfiles`. Stattdessen handelt es sich um eine Berechtigung, die AWS überprüft, wann immer ein Rollen-ARN als Parameter an eine API übergeben wird (oder die Konsole dies im Namen des Benutzers tut). Damit kann der Administrator steuern, welche Rollen von welchen Benutzern übergeben werden dürfen. In diesem Fall wird sichergestellt, dass der Benutzer eine spezifische Rolle einer Amazon EC2-Instance anfügen darf.

**Example Beispielrichtlinie, mit der eine Benutzerberechtigung zum Starten einer Amazon-EC2-Instance mit einer bestimmten Rolle erteilt wird**  
In der folgenden Beispielrichtlinie wird den Benutzern ermöglicht, die Amazon EC2-API zum Starten einer Instance mit einer Rolle zu verwenden. Das Element `Resource` gibt den Amazon-Ressourcenamen (ARN) einer Rolle an. Indem Sie den ARN angeben, erteilt die Richtlinie dem Benutzer die Berechtigung, nur die Rolle `Get-pics` zu übergeben. Wenn der Benutzer versucht, eine andere Rolle beim Starten einer Instance anzugeben, schlägt die Aktion fehl. Der Benutzer ist nicht zum Ausführen einer beliebigen Instance berechtigt, unabhängig davon, ob er eine Rolle übergibt.    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "ec2:RunInstances",
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::111122223333:role/Get-pics"
        }
    ]
}
```

### Einer Instance-Profilrolle den Wechsel zu einer Rolle in eine anderen Konto erlauben
<a name="switch-role-ec2-another-account"></a>

Sie können einer Anwendung, die auf einer Amazon EC2-Instance ausgeführt wird, das Ausführen von Befehlen in einem anderen Konto erlauben. Dazu müssen Sie der Amazon-EC2-Instance-Rolle im ersten Konto den Wechsel zu einer Rolle im zweiten Konto erlauben.

Stellen Sie sich vor, Sie verwenden zwei AWS-Konten und möchten einer Anwendung, die auf einer Amazon EC2 EC2-Instance ausgeführt wird, erlauben, [AWS CLI](https://aws.amazon.com/cli/)Befehle in beiden Konten auszuführen. Gehen Sie davon aus, dass die Amazon-EC2-Instance im Konto `111111111111` vorhanden ist. Diese Instance enthält die `abcd`-Instance-Profilrolle, die der Anwendung erlaubt, schreibgeschützte Amazon S3-Aufgaben für den `amzn-s3-demo-bucket1`-Bucket innerhalb desselben `111111111111` Kontos auszuführen. Die Anwendung muss jedoch auch die Möglichkeit haben, die `efgh`-kontoübergreifende Rolle anzunehmen, um auf den Amazon S3-Bucket `amzn-s3-demo-bucket2` im Konto `222222222222` zuzugreifen.

![\[Das Diagramm zeigt, wie ein Entwickler eine Amazon-EC2-Instance mit der Rolle startet, um Zugriff auf Fotos in einem Amazon-S3-Bucket zu erhalten.\]](http://docs.aws.amazon.com/de_de/IAM/latest/UserGuide/images/roles-instance-profile-cross-account.png)


Der Instance-Profil-Rolle `abcd` von Amazon EC2 muss die folgende Berechtigungsrichtlinie zugeordnet sein, damit die Anwendung auf den `amzn-s3-demo-bucket1` Amazon-S3-Bucket zugreifen kann:

***Konto 111111111111 `abcd` Rollen-Berechtigungsrichtlinie***

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket1/*",
                "arn:aws:s3:::amzn-s3-demo-bucket1"
            ]
        },
        {
            "Sid": "AllowIPToAssumeCrossAccountRole",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::222222222222:role/efgh"
        }
    ]
}
```

------

Die `abcd`-Rolle muss dem Amazon EC2-Service vertrauen, um die Rolle anzunehmen. Dazu benötigt die `abcd`-Rolle die folgende Vertrauensrichtlinie:

***Konto 111111111111 `abcd` Rolle Treuhandpolitik***

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

****  

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

------

Gehen Sie davon aus, dass die kontoübergreifende `efgh`-Rolle die Ausführung schreibgeschützter Amazon S3-Aufgaben für den `amzn-s3-demo-bucket2`-Bucket im selben `222222222222`-Konto zulässt. Dazu muss der kontoübergreifenden `efgh`-Rolle die folgende Berechtigungsrichtlinie zugeordnet sein:

***Konto 222222222222 `efgh` Rollen-Berechtigungsrichtlinie***

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowAccountLevelS3Actions",
            "Effect": "Allow",
            "Action": [
                "s3:GetBucketLocation",
                "s3:GetAccountPublicAccessBlock",
                "s3:ListAccessPoints",
                "s3:ListAllMyBuckets"
            ],
            "Resource": "arn:aws:s3:::*"
        },
        {
            "Sid": "AllowListAndReadS3ActionOnMyBucket",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket2/*",
                "arn:aws:s3:::amzn-s3-demo-bucket2"
            ]
        }
    ]
}
```

------

Die `efgh`-Rolle muss für die Übernahme der `abcd`-Instance-Profilrolle vertrauen. Dazu benötigt die `efgh`-Rolle die folgende Vertrauensrichtlinie:

***Konto 222222222222 `efgh` Rolle Treuhandpolitik***

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "efghTrustPolicy",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {"AWS": "arn:aws:iam::111111111111:role/abcd"}
        }
    ]
}
```

------

## Was sind die ersten Schritte?
<a name="roles-usingrole-ec2instance-get-started"></a>

Um die Funktionsweise einer Rolle mit Amazon-EC2-Instances nachzuvollziehen, müssen Sie mithilfe der IAM-Konsole eine Rolle erstellen, eine Amazon-EC2-Instance starten, die diese Rolle verwendet und dann die laufende Instance analysieren. Sie können die [Instance-Metadaten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) untersuchen, um nachzuvollziehen, wie die Instance die temporären Anmeldeinformationen der Rolle erhält. Sie können außerdem nachvollziehen, wie eine auf der Instance ausgeführte Anwendung diese Rolle verwenden kann. Verwenden Sie die folgenden Ressourcen, um weitere Informationen zu erhalten. 
+ [Tutorial zu IAM-Rollen auf Amazon-EC2-Instances.](https://www.youtube.com/watch?v=TlCuOjviOhk). Das verknüpfte Video zeigt, wie man eine IAM-Rolle mit einer Amazon-EC2-Instance verwendet, um zu steuern, was eine Anwendung machen darf, wenn sie auf der Instance ausgeführt wird. Das Video zeigt, wie die (im AWS SDK geschriebene) Anwendung über die Rolle temporäre Sicherheitsanmeldedaten abrufen kann. 
+ SDK-Anleitungen. Die AWS SDK-Dokumentation enthält exemplarische Vorgehensweisen, die eine Anwendung zeigen, die auf einer Amazon EC2 EC2-Instance ausgeführt wird und temporäre Anmeldeinformationen für Rollen verwendet, um einen Amazon S3 S3-Bucket zu lesen. Jede der folgenden Anleitungen beschreibt die gleiche Vorgehensweise in einer anderen Programmiersprache:
  + [Konfigurieren von IAM-Rollen Amazon EC2 mit dem SDK for Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java-dg-roles.html) im *AWS SDK für Java Developer Guide* 
  + [Starten einer Amazon-EC2-Instance mit dem SDK für .NET ](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/run-instance.html) im *AWS SDK für .NET -Entwicklerhandbuch*
  + [Erstellen einer Amazon EC2 Instance mit dem SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby/latest/developer-guide/ec2-example-create-instance.html) im *AWS SDK für Ruby Developer Guide*

## Ähnliche Informationen
<a name="roles-usingrole-ec2instance-related-info"></a>

Weitere Informationen zum Erstellen von Rollen für Amazon-EC2-Instances finden Sie in den folgenden Informationen:
+ Weitere Informationen zur [Verwendung von IAM-Rollen mit Amazon-EC2-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) finden Sie im *Amazon-EC2-Benutzerhandbuch*.
+ Informationen zum Erstellen einer Rolle finden Sie unter [Erstellung einer IAM-Rolle](id_roles_create.md).
+ Weitere Informationen zum Verwenden von temporären Sicherheitsanmeldeinformationen finden Sie unter [Temporäre IAM Sicherheitsanmeldeinformationen](id_credentials_temp.md).
+ Wenn Sie mit der IAM-API oder der Befehlszeilenschnittstelle (CLI) arbeiten möchten, müssen Sie IAM-Instance-Profile erstellen und verwalten. Weitere Informationen zu Instance-Profilen finden Sie unter [Verwendung von Instance-Profilen](id_roles_use_switch-role-ec2_instance-profiles.md).
+ Weitere Informationen zu temporären Sicherheits-Anmeldeinformationen für Rollen in den Instance-Metadaten finden Sie unter [Abrufen von Sicherheits-Anmeldeinformationen aus Instance-Metadaten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials) im *Amazon-EC2-Benutzerhandbuch*.

# Verwendung von Instance-Profilen
<a name="id_roles_use_switch-role-ec2_instance-profiles"></a>

Verwenden Sie ein Instance-Profil, um eine IAM-Rolle an eine EC2-Instance zu übergeben. Weitere Informationen finden Sie unter [IAM-Rollen für Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) im *Amazon-EC2-Benutzerhandbuch*.

## Verwalten von Instance-Profilen (Konsole)
<a name="instance-profiles-manage-console"></a>

Wenn Sie die verwenden AWS-Managementkonsole , um eine Rolle für Amazon EC2 zu erstellen, erstellt die Konsole automatisch ein Instance-Profil und weist diesem den gleichen Namen wie die Rolle zu. Wenn Sie dann die Amazon EC2-Konsole verwenden, um eine Instance mit einer IAM-Rolle zu starten, können Sie eine Rolle auswählen, die der Instance zugewiesen wird. In der Konsole ist die Liste, die angezeigt wird, tatsächlich eine Liste von Instance-Profilnamen. Die Konsole erstellt kein Instance-Profil für eine Rolle, die nicht mit Amazon EC2 verknüpft ist.

Sie können die verwenden AWS-Managementkonsole , um IAM-Rollen und Instance-Profile für Amazon EC2 zu löschen, wenn die Rolle und das Instance-Profil denselben Namen haben. Weitere Informationen zum Löschen von Instanceprofilen finden Sie unter [Rollen oder Instance-Profile löschen](id_roles_manage_delete.md).

**Anmerkung**  
Zum Aktualisieren der Berechtigungen für eine Instance ersetzen Sie das Instance-Profil. Das Entfernen einer Rolle aus einem Instance-Profil wird nicht empfohlen, da es bis zu einer Stunde dauern kann, bis diese Änderung wirksam wird.

## Verwaltung von Instanzprofilen (AWS CLI oder AWS API)
<a name="instance-profiles-manage-cli-api"></a>

Wenn Sie Ihre Rollen über die AWS CLI oder die AWS API verwalten, erstellen Sie Rollen und Instanzprofile als separate Aktionen. Da Rollen und Instance-Profile unterschiedliche Namen haben können, müssen Sie die Namen der Instance-Profile sowie die Namen der Rollen kennen, die sie enthalten. Auf diese Weise können Sie das richtige Instance-Profil wählen, wenn Sie eine EC2 Instance starten. 

Sie können Ihren IAM-Ressourcen Tags anfügen, einschließlich Instance-Profile, um den Zugriff auf sie zu identifizieren, zu organisieren und zu kontrollieren. Sie können Instanzprofile nur taggen, wenn Sie die AWS API AWS CLI oder verwenden. 

**Anmerkung**  
Ein Instance-Profil kann nur eine einzige IAM-Rolle enthalten, eine Rolle kann jedoch in mehreren Instance-Profile enthalten sein. Diese Beschränkung auf eine Rolle pro Instance-Profil kann nicht erhöht werden. Sie können die vorhandene Rolle entfernen und dann eine andere Rolle zu einem Instance-Profil hinzufügen. AWS Aus Gründen der [Konsistenz müssen Sie dann warten, bis die Änderung für alle sichtbar ist](https://en.wikipedia.org/wiki/Eventual_consistency). Wenn Sie die Änderung erzwingen möchten, müssen Sie [die Zuweisung des Instance-Profils aufheben](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html) und dann [das Instance-Profil zuweisen](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html), oder Sie beenden Ihre Instance und starten sie neu.

### Verwalten von Instance-Profilen (AWS CLI)
<a name="instance-profiles-manage-cli"></a>

Sie können die folgenden AWS CLI Befehle verwenden, um mit Instanzprofilen in einem AWS Konto zu arbeiten. 
+ Erstellen eines Instance-Profils: [https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-instance-profile.html)
+ Markieren eines Instance-Profils: [https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/tag-instance-profile.html)
+ Auflisten von Tags für ein Instance-Profil: [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profile-tags.html)
+ Entfernen der Markierung eines Instance-Profils: [https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/untag-instance-profile.html)
+ Hinzufügen einer Rolle zu einem Instance-Profil: [https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/add-role-to-instance-profile.html) 
+ Auflisten von Instance-Profilen: [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles.html), [https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-instance-profiles-for-role.html) 
+ Abrufen von Informationen zu einem Instance-Profil: [https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/get-instance-profile.html) 
+ Entfernen einer Rolle aus einem Instance-Profil: [https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/remove-role-from-instance-profile.html)
+ Löschen eines Instance-Profils: [https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-instance-profile.html) 

Mithilfe der folgenden Befehle können Sie eine Rolle auch einer bereits ausgeführten EC2-Instance anfügen. Weitere Informationen finden Sie unter [IAM-Rollen für Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
+ Anfügen eines Instance-Profils mit einer Rolle an eine angehaltene oder ausgeführte EC2-Instance: [https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-iam-instance-profile.html) 
+ Abrufen von Informationen zu einem Instance-Profil, das an eine EC2-Instance angefügt ist: [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-iam-instance-profile-associations.html) 
+ Trennen eines Instance-Profils mit einer Rolle von einer angehaltenen oder ausgeführten EC2-Instance: [https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-iam-instance-profile.html) 

### Verwaltung von Instanzprofilen (AWS API)
<a name="instance-profiles-manage-api"></a>

Sie können die folgenden AWS API-Operationen aufrufen, um mit Instanzprofilen in einem zu arbeiten AWS-Konto.
+ Erstellen eines Instance-Profils: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateInstanceProfile.html) 
+ Markieren eines Instance-Profils: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Auflisten von Tags auf einem Instance-Profil: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Entfernen der Markierung eines Instance-Profils: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_TagInstanceProfile.html) 
+ Hinzufügen einer Rolle zu einem Instance-Profil: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html) 
+ Auflisten von Instance-Profilen: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfiles.html), [https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListInstanceProfilesForRole.html) 
+ Abrufen von Informationen zu einem Instance-Profil: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetInstanceProfile.html) 
+ Entfernen einer Rolle aus einem Instance-Profil: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_RemoveRoleFromInstanceProfile.html) 
+ Löschen eines Instance-Profils: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteInstanceProfile.html) 

Außerdem können Sie eine Rolle einer bereits ausgeführten EC2 Instance anfügen, indem Sie die folgenden Operationen aufrufen. Weitere Informationen finden Sie unter [IAM-Rollen für Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
+ Anfügen eines Instance-Profils mit einer Rolle an eine angehaltene oder ausgeführte EC2-Instance: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html) 
+ Abrufen von Informationen zu einem Instance-Profil, das an eine EC2-Instance angefügt ist: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeIamInstanceProfileAssociations.html) 
+ Trennen eines Instance-Profils mit einer Rolle von einer angehaltenen oder ausgeführten EC2-Instance: [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html)