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.
# Authentifizierungs- und Zugangsdaten für die AWS CLI
Sie müssen AWS bei der Entwicklung mit Diensten festlegen, wie AWS CLI sich das authentifiziert. AWS Wählen Sie eine der folgenden Optionen AWS CLI, um Anmeldeinformationen für den programmatischen Zugriff auf zu konfigurieren. Die Optionen sind in der Reihenfolge aufgeführt, in der sie empfohlen werden.
****
| Authentifizierungstyp | Zweck | Anleitungen |
| --- | --- | --- |
| AWS Anmeldeinformationen für die Managementkonsole | **(Empfohlen)** Verwenden Sie kurzfristige Anmeldeinformationen, indem Sie sich mit Ihren Konsolenanmeldedaten bei der AWS CLI anmelden. Wird empfohlen, wenn Sie Root, IAM-Benutzer oder einen Verbund mit IAM für AWS den Kontozugriff verwenden | [Melden Sie sich mit Konsolenanmeldedaten für die AWS lokale Entwicklung an](cli-configure-sign-in.md) |
| Kurzfristige Anmeldeinformationen für Unternehmensbenutzer von IAM Identity Center | Verwenden Sie kurzfristige Anmeldeinformationen für einen IAM Identity Center Workforce-Benutzer.Die bewährte Sicherheitsmethode ist die Verwendung AWS Organizations mit IAM Identity Center. Dabei werden kurzfristige Anmeldeinformationen mit einem Benutzerverzeichnis wie dem integrierten Verzeichnis von IAM Identity Center oder Active Directory kombiniert. | [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md) |
| Kurzfristige Anmeldeinformationen für IAM-Benutzer | Verwenden Sie kurzfristige Anmeldeinformationen für IAM-Benutzer, die sicherer als langfristige Anmeldeinformationen sind. Wenn Ihre Anmeldeinformationen kompromittiert werden, können sie nur für einen begrenzten Zeitraum verwendet werden, bevor sie ablaufen. | [Authentifizierung mit kurzfristigen Zugangsdaten für den AWS CLI](cli-authentication-short-term.md) |
| Benutzer von IAM oder IAM Identity Center auf einer Amazon-EC2-Instance | Verwenden Sie Metadaten einer Amazon-EC2-Instance, um mithilfe der Rolle, die der Amazon-EC2-Instance zugewiesen ist, temporäre Anmeldeinformationen abzufragen. | [Verwendung von Amazon EC2 EC2-Instance-Metadaten als Anmeldeinformationen in der AWS CLI](cli-configure-metadata.md) |
| Übernehmen von Rollen für Berechtigungen | Kombinieren Sie eine andere Anmeldeinformationsmethode und übernehmen Sie eine Rolle für den temporären Zugriff auf AWS-Services , auf die Ihr Benutzer möglicherweise keinen Zugriff hat. | [Verwenden einer IAM-Rolle in der AWS CLI](cli-configure-role.md) |
| Langfristige Anmeldeinformationen für IAM-Benutzer | (Nicht empfohlen) Verwenden Sie langfristige Anmeldeinformationen ohne Ablaufdatum. | [Authentifizierung mit IAM-Benutzeranmeldedaten für AWS CLI](cli-authentication-user.md) |
| Externe Speicherung für Unternehmensbenutzer von IAM oder IAM Identity Center | (Nicht empfohlen) Sie kombinieren mit einer anderen Anmeldeinformationsmethode, speichern die Anmeldeinformationswerte jedoch an einem Ort außerhalb der AWS CLI. Diese Methode ist nur so sicher wie der externe Ort, an dem die Anmeldeinformationen gespeichert werden. | [Beschaffung von Referenzen mit einem externen Prozess in der AWS CLI](cli-configure-sourcing-external.md) |
## Vorrang der Konfiguration und der Anmeldeinformationen
Anmeldeinformationen und Konfigurationseinstellungen befinden sich an mehreren Stellen, z. B. in den System- oder Benutzerumgebungsvariablen, in lokalen AWS Konfigurationsdateien oder werden explizit in der Befehlszeile als Parameter deklariert. Bestimmte Authentifizierungen haben Vorrang vor anderen. Die AWS CLI -Authentifizierungseinstellungen haben Vorrang in der folgenden Reihenfolge:
1. **[Befehlszeilenoptionen](cli-configure-options.md)** – überschreiben Einstellungen an jedem anderen Speicherort, z. B. die Parameter `--region`, `--output` und `--profile`.
1. **[Umgebungsvariablen](cli-configure-envvars.md)** – Sie können Werte in den Umgebungsvariablen Ihres Systems speichern.
1. **[Rolle übernehmen](cli-configure-role.md)** – übernehmen Sie die Berechtigungen einer IAM-Rolle durch die Konfiguration oder den Befehl [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html).
1. **[Rolle mit Webidentität übernehmen](cli-configure-role.md)** – übernehmen Sie die Berechtigungen einer IAM-Rolle mit Webidentität durch die Konfiguration oder den Befehl [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).
1. **[AWS IAM Identity Center](cli-configure-files.md)** – Die in der Datei `config` gespeicherten Konfigurationseinstellungen für IAM Identity Center werden aktualisiert, wenn Sie den Befehl `aws configure sso` ausführen. Die Anmeldeinformationen werden dann authentifiziert, wenn Sie den Befehl `aws sso login` ausführen. Die Datei `config` befindet sich in `~/.aws/config` unter Linux und in macOS oder in `C:\Users\USERNAME\.aws\config` unter Windows.
1. **[Anmeldeinformationsdatei](cli-configure-files.md)** – die Dateien `credentials` und `config` werden aktualisiert, wenn Sie den Befehl `aws configure` ausführen. Die Datei `credentials` befindet sich in `~/.aws/credentials` unter Linux und in macOS oder in `C:\Users\USERNAME\.aws\credentials` unter Windows.
1. **[Benutzerdefinierter Prozess](cli-configure-sourcing-external.md)** – rufen Sie Ihre Anmeldeinformationen von einer externen Quelle ab.
1. **[Konfigurationsdatei](cli-configure-files.md)** – die Dateien `credentials` und `config` werden aktualisiert, wenn Sie den Befehl `aws configure` ausführen. Die Datei `config` befindet sich in `~/.aws/config` unter Linux und in macOS oder in `C:\Users\USERNAME\.aws\config` unter Windows.
1. **[Container Anmeldeinformationen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)** Sie können eine IAM-Rolle mit jeder Ihrer Amazon-Elastic-Container-Service-(Amazon-ECS)-Aufgabendefinitionen verknüpfen. Temporäre Anmeldeinformationen für diese Rolle stehen dann für die Container dieser Aufgabe zur Verfügung. Weitere Informationen finden Sie unter [IAM-Rollen für Aufgaben](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) im *Entwicklerhandbuch zum Amazon Elastic Container Service*.
1. **[Amazon-EC2-Instance-Profil-Anmeldeinformationen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)** – Sie können eine IAM-Rolle mit jeder Ihrer Amazon-Elastic-Compute-Cloud(Amazon-EC2)-Instances verknüpfen. Temporäre Anmeldeinformationen für diese Rolle stehen dann für den Code zur Verfügung, der in dieser Instance ausgeführt wird. Die Anmeldeinformationen werden über den Amazon-EC2-Metadaten-Service bereitgestellt. 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* und unter [Verwenden von Instance-Profilen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) im *IAM-Benutzerhandbuch*.
## Weitere Themen in diesem Abschnitt
+ [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md)
+ [Authentifizierung mit kurzfristigen Zugangsdaten für den AWS CLI](cli-authentication-short-term.md)
+ [Verwenden einer IAM-Rolle in der AWS CLI](cli-configure-role.md)
+ [Authentifizierung mit IAM-Benutzeranmeldedaten für AWS CLI](cli-authentication-user.md)
+ [Verwendung von Amazon EC2 EC2-Instance-Metadaten als Anmeldeinformationen in der AWS CLI](cli-configure-metadata.md)
+ [Beschaffung von Referenzen mit einem externen Prozess in der AWS CLI](cli-configure-sourcing-external.md)
# Melden Sie sich mit Konsolenanmeldedaten für die AWS lokale Entwicklung an
Sie können Ihre vorhandenen Anmeldedaten für die AWS Management Console für den programmgesteuerten Zugriff AWS auf Dienste verwenden. AWS Generiert nach einem browserbasierten Authentifizierungsablauf temporäre Anmeldeinformationen, die in allen lokalen Entwicklungstools wie AWS CLI, AWS Tools for PowerShell und AWS SDKs funktionieren. Diese Funktion vereinfacht die Konfiguration und Verwaltung von AWS CLI-Anmeldeinformationen, insbesondere wenn Sie die interaktive Authentifizierung der Verwaltung von langfristigen Zugriffsschlüsseln vorziehen.
Mit diesem Prozess können Sie sich mit Root-Anmeldeinformationen, die bei der ersten Kontoeinrichtung erstellt wurden, mit einem IAM-Benutzer oder einer föderierten Identität von Ihrem Identitätsanbieter authentifizieren. Die AWS CLI verwaltet die temporären Anmeldeinformationen automatisch für Sie. Dieser Ansatz erhöht die Sicherheit, da die Notwendigkeit entfällt, langfristige Anmeldeinformationen lokal zu speichern.
Wenn Sie den `aws login` Befehl ausführen, können Sie aus Ihren aktiven Konsolensitzungen wählen oder sich über den browserbasierten Authentifizierungsablauf anmelden. Dabei werden automatisch temporäre Anmeldeinformationen generiert. Die CLI aktualisiert diese Anmeldeinformationen automatisch für bis zu 12 Stunden.
Nach der Konfiguration kann Ihre Sitzung in der AWS CLI AWS SDKs und anderen Tools verwendet werden.
**Topics**
+ [Voraussetzungen](#cli-configure-sign-in-prerequisites)
+ [Melden Sie sich mit dem `aws login` Befehl bei der AWS CLI an.](#cli-configure-sign-in-login-command)
+ [Führen Sie einen Befehl mit Ihrem Profil aus](#cli-configure-sign-in-with-profile)
+ [Melden Sie sich mit dem Befehl aws logout von Ihrer Sitzung ab](#cli-configure-sign-in-sign-out)
+ [Fehlerbehebung](#cli-configure-sign-in-troubleshooting)
+ [Zugehörige Ressourcen](#cli-configure-sign-in-resources)
## Voraussetzungen
+ Installieren Sie die AWS CLI. Weitere Informationen finden Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md). Für die Verwendung des Befehls ist eine Mindestversion von 2.32.0 erforderlich. `aws login`
+ Zugriff, um sich als Root-Benutzer, IAM-Benutzer oder über einen Verbund mit IAM bei der AWS Management Console anzumelden. Wenn Sie IAM Identity Center verwenden, wechseln Sie stattdessen zu. [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md)
+ Stellen Sie sicher, dass die IAM-Identität über die entsprechenden Berechtigungen verfügt. Ordnen Sie die [SignInLocalDevelopmentAccess](https://docs.aws.amazon.com/signin/latest/userguide/security-iam-awsmanpol.html)verwaltete Richtlinie Ihrem IAM-Benutzer, Ihrer IAM-Rolle oder -Gruppe zu. Wenn Sie sich als Root-Benutzer anmelden, sind keine zusätzlichen Berechtigungen erforderlich.
## Melden Sie sich mit dem `aws login` Befehl bei der AWS CLI an.
Führen Sie den `aws login` Befehl aus, um sich mit Ihren vorhandenen Anmeldeinformationen für die AWS Management Console zu authentifizieren. Wenn Sie noch kein Profil konfiguriert haben, werden Sie zur Eingabe zusätzlicher Informationen aufgefordert. Gehen Sie wie folgt vor, um sich anzumelden oder ein Profil zu konfigurieren.
1. Führen Sie den Befehl `aws login` in Ihrem bevorzugten Terminal aus.
```
$ aws login
```
Verwenden Sie die `--profile` Option, um sich bei einem benannten Profil anzumelden oder ein neues zu erstellen.
```
$ aws login --profile my-dev-profile
```
+ Wenn es sich um ein neues Profil handelt oder keine AWS Region angegeben wurde, werden Sie von der AWS CLI aufgefordert, eine Region anzugeben.
```
No AWS region has been configured. The AWS region is the geographic location of
your AWS resources.
If you've used AWS before and already have resources in your account, tell us
which region they were created in. If you haven't created resources in your account
before, you can pick the region closest to you:
https://docs.aws.amazon.com/global-infrastructure/latest/regions/aws-regions.html.
You are able to change the region in the CLI at any time with the command
`aws configure set region NEW_REGION`.
AWS Region [us-east-1]:
```
+ Wenn das Gerät, das die AWS CLI verwendet, keinen Browser hat, können Sie die `--remote` Option verwenden, um eine URL bereitzustellen, die Sie auf einem browserfähigen Gerät öffnen können.
```
$ aws login --remote
```
**Anmerkung**
Sie können den Zugriff auf die Authentifizierung auf demselben Gerät (`aws login`) und auf die geräteübergreifende () Authentifizierung steuern. `aws login --remote` Verwenden Sie die folgende Ressource ARNs in jeder relevanten IAM-Richtlinie.
`arn:aws:signin:region:account-id:oauth2/public-client/localhost`— Verwenden Sie diesen ARN für die Authentifizierung auf demselben Gerät mit. `aws login`
`arn:aws:signin:region:account-id:oauth2/public-client/remote`— Verwenden Sie diesen ARN für die geräteübergreifende Authentifizierung mit`aws login --remote`.
1. Die AWS CLI versucht, Ihren Standardbrowser für den Anmeldevorgang Ihres AWS Kontos zu öffnen.
```
Attempting to open the login page for `us-east-1` in your default browser.
If the browser does not open, use the following URL to complete your login:
https://signin.us-east-1.amazonaws.com/authorize?
If you cannot connect to this URL, make sure that you have specified a valid region.
```
+ Wenn Sie `--remote` diese Option verwendet haben, werden je nach Art der verwendeten Autorisierung Anweisungen zum manuellen Starten des Anmeldevorgangs angezeigt. Die angezeigte URL ist eine eindeutige URL, die mit: https://us-east-1.signin.amazonaws.com /authorize beginnt. Sobald Sie die Browser-Anmeldung abgeschlossen haben, müssen Sie den resultierenden Autorisierungscode kopieren und wieder in die CLI einfügen.
```
Browser will not be automatically opened.
Please visit the following URL:
https://region.signin.amazonaws.com/authorize?
Please enter the authorization code displayed in the browser:
```
1. Wählen Sie im Browser Ihre zu verwendenden Anmeldeinformationen aus der angezeigten Liste aus und kehren Sie dann zu Ihrem Terminal zurück.
+ Wenn das Profil, das Sie konfigurieren, über eine zuvor konfigurierte Anmeldesitzung verfügt, die nicht mit Ihrer neuen Sitzung übereinstimmt, werden Sie von der AWS CLI aufgefordert, zu bestätigen, dass Sie die Sitzung wechseln, die dem vorhandenen Profil entspricht.
```
Profile signin is already configured to use session arn:aws:iam::0123456789012:user/ReadOnly.
Do you want to overwrite it to use arn:aws:iam::0123456789012:user/Admin instead? (y/n):.
```
1. Eine abschließende Meldung beschreibt die abgeschlossene Profilkonfiguration. Sie können dieses Profil nun verwenden, um Anmeldeinformationen anzufordern. Verwenden Sie den `aws login`-Befehl, um die Anmeldeinformationen, die zum Ausführen von Befehlen erforderlich sind, anzufordern und abzurufen.
Das Authentifizierungstoken wird auf der Festplatte unter dem `.aws/login/cache` Verzeichnis mit einem Dateinamen zwischengespeichert, der auf dem aufgelösten Profil basiert.
### Generierte Konfigurationsdatei
Diese Schritte führen zur Erstellung des `default` Profils in der `config` Datei, das wie folgt aussieht:
```
[default]
login_session = arn:aws:iam::0123456789012:user/username
region = us-east-1
```
## Führen Sie einen Befehl mit Ihrem Profil aus
Sobald Sie angemeldet sind, können Sie Ihre Anmeldeinformationen verwenden, um AWS CLI-Befehle mit dem zugehörigen Profil aufzurufen. Im folgenden Beispiel wird der `get-caller-identity` Befehl mithilfe des `default` Profils aufgerufen:
```
$ aws sts get-caller-identity
```
Verwenden Sie die `--profile` Option, um sich bei einer bestimmten Sitzung anzumelden.
```
$ aws sts get-caller-identity --profile my-dev-profile
```
Die AWS CLI aktualisiert die zwischengespeicherten Anmeldeinformationen bei Bedarf automatisch alle 15 Minuten. SDKs Die Gesamtsitzung ist bis zu der für den IAM-Prinzipal festgelegten Sitzungsdauer (maximal 12 Stunden) gültig. Danach müssen Sie sie erneut ausführen`aws login`.
## Melden Sie sich mit dem Befehl aws logout von Ihrer Sitzung ab
Wenn Sie Ihre Sitzung nicht mehr verwenden, können Sie Ihre Anmeldeinformationen ablaufen lassen oder den `aws logout` Befehl ausführen, um Ihre zwischengespeicherten Anmeldeinformationen zu löschen. Wenn in der Befehlszeile oder in der `AWS_PROFILE` Umgebungsvariablen kein Profil angegeben ist, meldet der Befehl Sie von Ihrem Standardprofil ab. Im folgenden Beispiel werden Sie von Ihrem Standardprofil abgemeldet.
```
$ aws logout
```
Verwenden Sie die `--profile` Option, um sich von einer bestimmten Sitzung abzumelden.
```
$ aws logout --profile my-dev-profile
```
Verwenden Sie die `--all` Option, um sich von allen Profilen abzumelden, die Anmeldeinformationen verwenden.
```
$ aws logout --all
```
### Anmeldeinformationen im Cache
Die temporär zwischengespeicherten Anmeldeinformationen sowie die Metadaten, die für ihre Aktualisierung erforderlich sind, werden standardmäßig `~/.aws/login/cache` unter Linux und macOS oder `%USERPROFILE%\.aws\login\cache` unter Windows gespeichert.
Um den Cache für kurzfristige Anmeldeinformationen an einem anderen Ort zu speichern, legen Sie die `AWS_LOGIN_CACHE_DIRECTORY` Umgebungsvariable fest.
#### Anmeldeinformationen als Prozessanmeldedaten teilen
Ältere Versionen der AWS SDKs oder anderer Entwicklungstools unterstützen möglicherweise noch keine Konsolenanmeldedaten. Um das Problem zu umgehen, können Sie die AWS CLI so konfigurieren, dass sie als Anbieter von Prozessanmeldeinformationen dient. Die CLI aktualisiert die Anmeldeinformationen weiterhin nach Bedarf und gibt sie gleichzeitig an Tools weiter, die für die Verwendung des credentials al\$1process-Profils konfiguriert sind.
Verwenden Sie in diesem Beispiel die AWS CLI, um sich zuerst für die Profilanmeldung anzumelden:
```
$ aws login --profile signin
```
Konfigurieren Sie dann manuell ein Profil mit der Option credentials al\$1process, die auf das Anmeldeprofil zurückverweist. Jetzt können Sie unsere Tools für die Verwendung des Prozessprofils konfigurieren SDKs , wodurch die CLI aufgerufen wird, um die Anmeldeinformationen aus dem Anmeldeprofil weiterzugeben.
```
[profile signin]
login_session = arn:aws:iam::0123456789012:user/username
region = us-east-1
[profile process]
credential_process = aws configure export-credentials --profile signin --format process
region = us-east-1
```
## Fehlerbehebung
Diese Seite enthält Empfehlungen zur Behebung von Problemen bei der Anmeldung für die AWS lokale Entwicklung mithilfe der Konsolenanmeldeinformationen für die AWS CLI.
**Anmerkung**
Informationen zur Behebung anderer Probleme, auf die Sie möglicherweise bei der Verwendung der AWS CLI stoßen, finden Sie unter[Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md).
### ExpiredToken oder AccessDeniedException Fehler nach der Verwendung von „aws login“
Wenn Sie einen AWS CLI-Befehl ausführen, nachdem er `aws login` für ein bestimmtes Profil ausgeführt wurde, kann ein Fehler mit abgelaufenen oder ungültigen Anmeldeinformationen auftreten.
```
$ aws s3 ls
An error occurred (ExpiredToken) when calling the ListBuckets operation: The provided token has expired.
```
**Mögliche Ursache:** Sie haben eine Mischung aus vorhandenen Anmeldeinformationen und den neuen Anmeldeinformationen in diesem Profil
Führen Sie `aws configure list` oder aus`aws configure list --profile `, um zu drucken, woher die CLI Anmeldeinformationen für das Standard- oder das angegebene Profil auflöst.
Wenn die Spalte TYPE etwas anderes als login ist, bedeutet dies, dass im Zielprofil immer noch ein anderer Typ von Anmeldeinformationen festgelegt ist.
In diesem Beispiel werden Anmeldeinformationen aus der Datei mit gemeinsamen Anmeldeinformationen in Ihrem Home-Verzeichnis aufgelöst, die Vorrang vor den Anmeldeinformationen hat.
```
$ aws configure list
NAME : VALUE : TYPE : LOCATION
profile : : None : None
access_key : ****************MPLE : shared-credentials-file :
secret_key : ****************EKEY : shared-credentials-file :
region : us-east-1 : config-file : ~/.aws/config
```
Um dieses Problem zu beheben, entfernen Sie manuell alle vorhandenen Anmeldeinformationen aus Ihrer Konfiguration und der Anmeldeinformationsdatei für das Zielprofil. Sobald Sie dies getan haben, sollten Sie bei der `aws configure list` erneuten Ausführung die Anmeldeinformationen sehen.
```
$ aws configure list
NAME : VALUE : TYPE : LOCATION
profile : : None : None
access_key : ****************MPLE : login :
secret_key : ****************EKEY : login :
region : us-east-1 : config-file : ~/.aws/config
```
Alternativ zeigt die Verwendung der `--debug` Option, woher die CLI Anmeldeinformationen auflöst.
### Die Firewall blockiert den Netzwerkzugriff, wenn „aws login“ ausgeführt wird
`aws login`Beim Ausführen wird möglicherweise ein Popup oder eine Meldung von Ihrer Firewall-Software angezeigt, die verhindert, dass die AWS CLI auf Ihr Netzwerk zugreift.
**Mögliche Ursache:** Ihre Firewall oder Sicherheitssoftware verhindert, dass die AWS CLI den Port öffnet, der für den OAuth Rückruf verwendet wurde.
Um dieses Problem zu vermeiden, verwenden Sie stattdessen die `--remote` Option. Dadurch werden Sie aufgefordert, den Autorisierungscode zu kopieren und einzufügen, anstatt den OAuth Rückruf zu verwenden.
```
$ aws login --remote
```
## Zugehörige Ressourcen
Die folgenden zusätzlichen Ressourcen stehen zur Verfügung.
+ [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md)
+ [`aws login`in der AWS CLI Version 2-Referenz](https://docs.aws.amazon.com/cli/latest/reference/)
+ [`aws logout`in der AWS CLI Version 2-Referenz](https://docs.aws.amazon.com/cli/latest/reference/)
# Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI
Dieses Thema enthält Anweisungen zur Konfiguration von AWS CLI with AWS IAM Identity Center (IAM Identity Center) zum Abrufen von Anmeldeinformationen für die Ausführung von Befehlen. AWS CLI Es gibt hauptsächlich zwei Möglichkeiten, Benutzer mit IAM Identity Center zu authentifizieren, um Anmeldeinformationen für die Ausführung von AWS CLI Befehlen über die Datei zu erhalten: `config`
+ **(Empfohlen)** Konfiguration des SSO-Token-Anbieters.
+ Nicht aktualisierbare Legacy-Konfiguration.
Informationen zur Verwendung der Bearer-Authentifizierung, die keine Konto-ID und Rolle verwendet, finden Sie unter [Einrichtung zur Verwendung von AWS CLI with CodeCatalyst](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html) im * CodeCatalyst Amazon-Benutzerhandbuch*.
**Anmerkung**
Eine Anleitung zur Verwendung von IAM Identity Center mit AWS CLI Befehlen finden Sie unter. [Tutorial: Verwenden von IAM Identity Center zur Ausführung von Amazon S3 S3-Befehlen in AWS CLI](cli-configure-sso-tutorial.md)
**Topics**
+ [Voraussetzungen](#cli-configure-sso-prereqs)
+ [Konfigurieren Ihres Profils mit dem `aws configure sso`-Assistenten](#cli-configure-sso-configure)
+ [Ausschließliches Konfigurieren des `sso-session`-Abschnitts mit dem `aws configure sso-session`-Assistenten](#cli-configure-sso-session)
+ [Manuelle Konfiguration mithilfe der `config`-Datei](#cli-configure-sso-manual)
+ [Anmelden für eine Sitzung in IAM Identity Center](#cli-configure-sso-login)
+ [Ausführen eines Befehls mit Ihrem Profil für IAM Identity Center](#cli-configure-sso-use)
+ [Abmelden von Ihren Sitzungen im IAM Identity Center](#cli-configure-sso-logout)
+ [Fehlerbehebung](#cli-configure-sso-tshoot)
+ [Zugehörige Ressourcen](#cli-configure-sso-resources)
## Voraussetzungen
+ Installieren Sie die AWS CLI. Weitere Informationen finden Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md).
+ Sie benötigen zunächst Zugriff auf die SSO-Authentifizierung in IAM Identity Center. Wählen Sie eine der folgenden Methoden, um auf Ihre AWS Anmeldeinformationen zuzugreifen.
### Ich habe keinen Zugriff über IAM Identity Center eingerichtet
Folgen Sie den Anweisungen unter [Erste Schritte](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) im *AWS IAM Identity Center -Benutzerhandbuch*. Dieser Prozess aktiviert IAM Identity Center, erstellt einen Administratorbenutzer und fügt einen entsprechenden Berechtigungssatz mit der geringsten Berechtigung hinzu.
**Anmerkung**
Erstellen Sie einen Berechtigungssatz, der Berechtigungen mit der geringsten Berechtigung anwendet. Wir empfehlen, den vordefinierten `PowerUserAccess`-Berechtigungssatz zu verwenden, es sei denn, Ihr Arbeitgeber hat zu diesem Zweck einen benutzerdefinierten Berechtigungssatz erstellt.
Verlassen Sie das Portal und melden Sie sich erneut an AWS-Konten, um Ihre programmatischen Zugangsdaten und Optionen für `Administrator` oder `PowerUserAccess` zu sehen. Wählen Sie `PowerUserAccess` aus, wenn Sie mit dem SDK arbeiten.
### Ich habe bereits AWS über einen von meinem Arbeitgeber verwalteten föderierten Identitätsanbieter Zugriff darauf (z. B. Azure AD oder Okta)
Melden Sie sich AWS über das Portal Ihres Identitätsanbieters an. Wenn Ihr Cloud-Administrator Ihnen `PowerUserAccess` (Entwickler-) Berechtigungen erteilt hat, sehen Sie, auf AWS-Konten welche Sie Zugriff haben, und Ihren Berechtigungssatz. Neben dem Namen Ihres Berechtigungssatzes sehen Sie Optionen für den manuellen oder programmgesteuerten Zugriff auf die Konten mithilfe dieses Berechtigungssatzes.
Benutzerdefinierte Implementierungen können zu unterschiedlichen Erfahrungen führen, z. B. zu unterschiedlichen Namen von Berechtigungssätzen. Wenn Sie sich nicht sicher sind, welchen Berechtigungssatz Sie verwenden sollen, wenden Sie sich an Ihr IT-Team.
### Ich habe bereits Zugriff auf AWS das von meinem Arbeitgeber verwaltete AWS Zugangsportal
Melden Sie sich AWS über Ihr AWS Zugangsportal an. Wenn Ihr Cloud-Administrator Ihnen `PowerUserAccess` (Entwickler-) Berechtigungen erteilt hat, sehen Sie, auf AWS-Konten welche Sie Zugriff haben, und Ihren Berechtigungssatz. Neben dem Namen Ihres Berechtigungssatzes sehen Sie Optionen für den manuellen oder programmgesteuerten Zugriff auf die Konten mithilfe dieses Berechtigungssatzes.
### Ich habe bereits AWS über einen föderierten Anbieter für benutzerdefinierte Identitäten, der von meinem Arbeitgeber verwaltet wird, Zugriff darauf
Wenden Sie sich an Ihr IT-Team, um Hilfe zu erhalten.
Nachdem Sie Zugriff auf IAM Identity Center erhalten haben, erfassen Sie Ihre Informationen für IAM Identity Center, indem Sie wie folgt vorgehen:
1. Sammeln Sie Ihre `SSO Region`- und `SSO Start URL`-Werte, die Sie für die Ausführung von `aws configure sso` benötigen.
1. Wählen Sie in Ihrem AWS Zugriffsportal den Berechtigungssatz aus, den Sie für die Entwicklung verwenden, und klicken Sie **auf den Link Zugriffstasten**.
1. Wählen Sie im Dialogfeld **Anmeldeinformationen abrufen** die Registerkarte aus, die Ihrem Betriebssystem entspricht.
1. Wählen Sie die Methode **Anmeldeinformationen für IAM Identity Center** aus, um die Werte für `SSO Start URL` und `SSO Region` abzurufen.
1. Alternativ können Sie ab Version 2.22.0 die Aussteller-URL anstelle der Start-URL verwenden. Die Aussteller-URL befindet sich in der AWS IAM Identity Center Konsole an einem der folgenden Orte:
+ Auf der **Dashboard**-Seite finden Sie die Aussteller-URL in der Einstellungsübersicht.
+ Auf der Seite **Einstellungen** finden Sie die Aussteller-URL in den Einstellungen für die **Identitätsquelle**.
1. Informationen dazu, welcher Bereichswert registriert werden muss, finden Sie unter [OAuth 2.0 Access Scopes](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) im *IAM Identity* Center-Benutzerhandbuch.
## Konfigurieren Ihres Profils mit dem `aws configure sso`-Assistenten
**So konfigurieren Sie ein Profil für IAM Identity Center für Ihre AWS CLI:**
1. Führen Sie den Befehl `aws configure sso` in Ihrem bevorzugten Terminal aus.
------
#### [ (Recommended) IAM Identity Center ]
Erstellen Sie einen Sitzungsnamen, geben Sie Ihre IAM Identity Center-Start-URL oder die Aussteller-URL, die URL, die AWS-Region das IAM Identity Center-Verzeichnis hostet, und den Registrierungsbereich an.
```
$ aws configure sso
SSO session name (Recommended): my-sso
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
Verwenden Sie für Dual-Stack-Unterstützung die Dual-Stack-SSO-Start-URL:
```
$ aws configure sso
SSO session name (Recommended): my-sso
SSO start URL [None]: https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
Die Autorisierung mit Proof Key for Code Exchange (PKCE) wird AWS CLI ab Version **2.22.0** standardmäßig verwendet und muss auf Geräten mit einem Browser verwendet werden. Um die Geräteautorisierung weiterhin zu verwenden, fügen Sie die Option `--use-device-code` hinzu.
```
$ aws configure sso --use-device-code
```
------
#### [ Legacy IAM Identity Center ]
Überspringen Sie den Sitzungsnamen und geben Sie Ihre Start-URL für IAM Identity Center sowie die AWS -Region an, in der sich das Identity-Center-Verzeichnis befindet.
```
$ aws configure sso
SSO session name (Recommended):
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]:us-east-1
```
Für Dual-Stack-Unterstützung:
```
$ aws configure sso
SSO session name (Recommended):
SSO start URL [None]: https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
SSO region [None]:us-east-1
```
------
1. Die AWS CLI Versuche, Ihren Standardbrowser für den Anmeldevorgang Ihres IAM Identity Center-Kontos zu öffnen. Bei diesem Vorgang werden Sie möglicherweise aufgefordert, den AWS CLI Zugriff auf Ihre Daten zuzulassen. Da AWS CLI das auf dem SDK für Python aufbaut, können Berechtigungsnachrichten Variationen des `botocore` Namens enthalten.
+ **Wenn der Browser AWS CLI nicht geöffnet** werden kann, werden je nach Art der von Ihnen verwendeten Autorisierung Anweisungen zum manuellen Starten des Anmeldevorgangs angezeigt.
------
#### [ PKCE authorization ]
Die Autorisierung mit Proof Key for Code Exchange (PKCE) wird standardmäßig AWS CLI ab Version 2.22.0 verwendet. Die angezeigte URL ist eine eindeutige URL, die beginnt mit:
+ IPv4: *https://oidc.us-east-1.amazonaws.com/authorize*
+ Dual-Stack: *https://oidc.us-east-1.api.aws/authorize*
Die PKCE-Autorisierung URLs muss auf demselben Gerät geöffnet werden, auf dem Sie sich anmelden, und für ein Gerät mit einem Browser verwendet werden.
```
Attempting to automatically open the SSO authorization page in your
default browser.
If the browser does not open or you wish to use a different device to
authorize the request, open the following URL:
https://oidc.us-east-1.amazonaws.com/authorize?
```
------
#### [ Device authorization ]
Die OAuth 2.0-Geräteautorisierung wird von allen Versionen verwendet, die AWS CLI älter als 2.22.0 sind. Sie können diese Methode in neueren Versionen mit der Option `--use-device-code` aktivieren.
Die Geräteautorisierung muss URLs nicht auf demselben Gerät geöffnet werden, auf dem Sie sich anmelden. Sie kann für Geräte mit oder ohne Browser verwendet werden. Das Endpunktformat hängt von Ihrer Konfiguration ab:
+ IPv4: *https://device.sso.us-west-2.amazonaws.com/*
+ Dual-Stack: *https://device.sso.us-west-2.api.aws/*
```
If the browser does not open or you wish to use a different device to
authorize this request, open the following URL:
https://device.sso.us-west-2.amazonaws.com/
Then enter the code:
QCFK-N451
```
------
1. Wählen Sie das zu verwendende AWS Konto aus der angezeigten Liste aus. Wenn Sie berechtigt sind, nur ein Konto zu verwenden, wählt das AWS CLI automatisch dieses Konto aus und überspringt die Eingabeaufforderung.
```
There are 2 AWS accounts available to you.
> DeveloperAccount, developer-account-admin@example.com (123456789011)
ProductionAccount, production-account-admin@example.com (123456789022)
```
1. Wählen Sie die zu verwendende IAM-Rolle aus der angezeigten Liste aus. Wenn nur eine Rolle verfügbar ist, wählt der AWS CLI automatisch diese Rolle aus und überspringt die Eingabeaufforderung.
```
Using the account ID 123456789011
There are 2 roles available to you.
> ReadOnly
FullAccess
```
1. Geben Sie das [Standardausgabeformat](cli-configure-files.md#cli-config-output), die [Standard- AWS-Region](cli-configure-files.md#cli-config-region) für das Senden von Befehlen und einen [Namen für das Profil](cli-configure-files.md) an. Wenn Sie `default` als Profilnamen angeben, wird dieses Profil als Standardprofil verwendet. Im folgenden Beispiel gibt der Benutzer eine Standardregion, ein Standardausgabeformat und den Namen des Profils ein.
```
Default client Region [None]: us-west-2
CLI default output format (json if not specified) [None]: json
Profile name [123456789011_ReadOnly]: my-dev-profile
```
1. Eine abschließende Meldung beschreibt die abgeschlossene Profilkonfiguration. Sie können dieses Profil nun verwenden, um Anmeldeinformationen anzufordern. Verwenden Sie den `aws sso login`-Befehl, um die Anmeldeinformationen, die zum Ausführen von Befehlen erforderlich sind, anzufordern und abzurufen. Detaillierte Anweisungen finden Sie unter [Anmelden für eine Sitzung in IAM Identity Center](#cli-configure-sso-login).
### Generierte Konfigurationsdatei
Diese Schritte führen dazu, dass der `sso-session`-Abschnitt und das benannte Profil in der `config`-Datei erstellt werden, die wie folgt aussieht:
------
#### [ IAM Identity Center ]
```
[profile my-dev-profile]
sso_session = my-sso
sso_account_id = 123456789011
sso_role_name = readOnly
region = us-west-2
output = json
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_registration_scopes = sso:account:access
```
Für Dual-Stack-Unterstützung:
```
[profile my-dev-profile]
sso_session = my-sso
sso_account_id = 123456789011
sso_role_name = readOnly
region = us-west-2
output = json
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_registration_scopes = sso:account:access
```
------
#### [ Legacy IAM Identity Center ]
```
[profile my-dev-profile]
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_region = us-east-1
sso_account_id = 123456789011
sso_role_name = readOnly
region = us-west-2
output = json
```
Für Dual-Stack-Unterstützung:
```
[profile my-dev-profile]
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_region = us-east-1
sso_account_id = 123456789011
sso_role_name = readOnly
region = us-west-2
output = json
```
------
## Ausschließliches Konfigurieren des `sso-session`-Abschnitts mit dem `aws configure sso-session`-Assistenten
**Anmerkung**
Diese Konfiguration ist nicht mit dem älteren IAM Identity Center kompatibel.
Der `aws configure sso-session`-Befehl aktualisiert nur die `sso-session`-Abschnitte in der `~/.aws/config`-Datei. Führen Sie den `aws configure sso-session` Befehl aus und geben Sie Ihre IAM Identity Center-Start-URL oder Aussteller-URL sowie die AWS Region an, in der das IAM Identity Center-Verzeichnis gehostet wird.
```
$ aws configure sso-session
SSO session name: my-sso
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
Verwenden Sie für Dual-Stack-Unterstützung die Dual-Stack-SSO-Start-URL:
```
$ aws configure sso-session
SSO session name: my-sso
SSO start URL [None]: https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
## Manuelle Konfiguration mithilfe der `config`-Datei
Die Konfigurationsinformationen für IAM Identity Center werden in der `config`-Datei gespeichert und können mit einem Texteditor bearbeitet werden. Um einem benannten Profil manuell Unterstützung für IAM Identity Center hinzuzufügen, müssen Sie der `config`-Datei Schlüssel und Werte hinzufügen.
### Konfigurationsdatei für IAM Identity Center
Der `sso-session` Abschnitt der `config` Datei wird verwendet, um Konfigurationsvariablen für den Erwerb von SSO-Zugriffstoken zu gruppieren, die dann zum Abrufen von Anmeldeinformationen verwendet werden können. AWS Die folgenden Einstellungen werden verwendet:
+ **(Erforderlich)** `sso\$1start\$1url`
+ **(Erforderlich)** `sso\$1region`
+ `sso\$1account\$1id`
+ `sso\$1role\$1name`
+ `sso\$1registration\$1scopes`
Sie definieren einen `sso-session`-Abschnitt und ordnen ihn einem Profil zu. Die Einstellungen `sso_region` und `sso_start_url` müssen innerhalb des `sso-session`-Abschnitts festgelegt werden. Normalerweise müssen `sso_account_id` und `sso_role_name` im `profile`-Abschnitt festgelegt werden, damit das SDK SSO-Anmeldeinformationen anfordern kann.
Im folgenden Beispiel wird das SDK für die Anforderung von SSO-Anmeldeinformationen konfiguriert und es wird eine automatische Token-Aktualisierung unterstützt:
```
[profile dev]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
```
Verwenden Sie für Dual-Stack-Unterstützung das Dual-Stack-SSO-Start-URL-Format:
```
[profile dev]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
```
Dadurch können `sso-session`-Konfigurationen zudem auch in mehreren Profilen wiederverwendet werden:
```
[profile dev]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[profile prod]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole2
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
```
Verwenden Sie für Dual-Stack-Unterstützung das Dual-Stack-SSO-Start-URL-Format:
```
[profile dev]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[profile prod]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole2
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
```
`sso_account_id` und `sso_role_name` sind jedoch nicht für alle Szenarien der SSO-Token-Konfiguration erforderlich. Wenn Ihre Anwendung nur AWS Dienste verwendet, die die Trägerauthentifizierung unterstützen, sind herkömmliche AWS Anmeldeinformationen nicht erforderlich. Bei der Bearer-Authentifizierung handelt es sich um ein HTTP-Authentifizierungsschema, das Sicherheitstoken, sogenannte Bearer-Token, verwendet. In diesem Szenario sind `sso_account_id` und `sso_role_name` nicht erforderlich. Lesen Sie im individuellen Leitfaden für Ihren AWS Dienst nach, ob er die Bearer-Token-Autorisierung unterstützt.
Darüber hinaus können Registrierungsbereiche als Teil von `sso-session` konfiguriert werden. Scope ist ein Mechanismus in OAuth 2.0, mit dem der Zugriff einer Anwendung auf das Konto eines Benutzers beschränkt werden kann. Eine Anwendung kann einen oder mehrere Bereiche anfordern und das an die Anwendung ausgegebene Zugriffstoken ist auf die gewährten Bereiche beschränkt. Diese Bereiche definieren die Berechtigungen, die für die Autorisierung für den registrierten OIDC-Client angefordert werden, und die vom Client abgerufenen Zugriffstoken. Im folgenden Beispiel wird `sso_registration_scopes` so festgelegt, dass der Zugriff zum Auflisten von Konten/Rollen möglich ist:
```
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_registration_scopes = sso:account:access
```
Für Dual-Stack-Unterstützung:
```
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_registration_scopes = sso:account:access
```
Das Authentifizierungs-Token wird auf der Festplatte unter dem Verzeichnis `sso/cache` mit einem Dateinamen zwischengespeichert, der auf dem Sitzungsnamen basiert.
### Konfigurationsdatei für das ältere IAM Identity Center
**Anmerkung**
Die automatisierte Token-Aktualisierung wird bei Verwendung der nicht aktualisierbaren Legacy-Konfiguration nicht unterstützt. Wir empfehlen die Verwendung der SSO-Token-Konfiguration.
Um einem benannten Profil manuell Unterstützung für IAM Identity Center hinzuzufügen, müssen Sie der Profildefinition in der `config`-Datei die folgenden Schlüssel und Werte hinzufügen.
+ `sso\$1start\$1url`
+ `sso\$1region`
+ `sso\$1account\$1id`
+ `sso\$1role\$1name`
Sie können auch andere Schlüssel und Werte einschließen, die in der `.aws/config`-Datei gültig sind. Das folgende Beispiel ist ein Profil für IAM Identity Center:
```
[profile my-sso-profile]
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_region = us-west-2
sso_account_id = 111122223333
sso_role_name = SSOReadOnlyRole
region = us-west-2
output = json
```
Für Dual-Stack-Unterstützung:
```
[profile my-sso-profile]
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_region = us-west-2
sso_account_id = 111122223333
sso_role_name = SSOReadOnlyRole
region = us-west-2
output = json
```
Um Befehle ausführen zu können, müssen Sie zuerst [Anmelden für eine Sitzung in IAM Identity Center](#cli-configure-sso-login) verwenden, um Ihre temporären Anmeldeinformationen anzufordern und abzurufen.
Weitere Informationen zu den Dateien `config` und `credentials` finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
## Anmelden für eine Sitzung in IAM Identity Center
**Anmerkung**
Beim Anmeldevorgang werden Sie möglicherweise aufgefordert, den AWS CLI Zugriff auf Ihre Daten zu gewähren. Da AWS CLI das auf dem SDK für Python aufbaut, können Berechtigungsnachrichten Variationen des `botocore` Namens enthalten.
Um eine Reihe von Anmeldeinformationen für IAM Identity Center abzurufen und zwischenzuspeichern, führen Sie den folgenden Befehl für die AWS CLI aus, um Ihren Standardbrowser zu öffnen und Ihre Anmeldung bei IAM Identity Center zu überprüfen.
```
$ aws sso login --profile my-dev-profile
SSO authorization page has automatically been opened in your default browser.
Follow the instructions in the browser to complete this authorization request.
Successfully logged into Start URL: https://my-sso-portal.awsapps.com/start
```
Ihre Anmeldeinformationen für die IAM Identity Center-Sitzung werden zwischengespeichert und dann AWS CLI verwendet, um AWS Anmeldeinformationen für die im Profil angegebene IAM-Rolle sicher abzurufen.
### Wenn der Ihren Browser nicht AWS CLI öffnen kann
Wenn Ihr Browser AWS CLI nicht automatisch geöffnet werden kann, werden je nach Art der von Ihnen verwendeten Autorisierung Anweisungen zum manuellen Starten des Anmeldevorgangs angezeigt.
------
#### [ PKCE authorization ]
Die Autorisierung mit Proof Key for Code Exchange (PKCE) wird AWS CLI ab Version 2.22.0 standardmäßig verwendet. Die angezeigte URL ist eine eindeutige URL, die beginnt mit:
+ IPv4: *https://oidc.us-east-1.amazonaws.com/authorize*
+ Dual-Stack: *https://oidc.us-east-1.api.aws/authorize*
Die PKCE-Autorisierung URLs muss auf demselben Gerät geöffnet werden, auf dem Sie sich anmelden, und für ein Gerät mit einem Browser verwendet werden.
```
Attempting to automatically open the SSO authorization page in your
default browser.
If the browser does not open or you wish to use a different device to
authorize the request, open the following URL:
https://oidc.us-east-1.amazonaws.com/authorize?
```
------
#### [ Device authorization ]
Die OAuth 2.0-Geräteautorisierung wird von allen Versionen verwendet, die AWS CLI älter als 2.22.0 sind. Sie können diese Methode in neueren Versionen mit der Option `--use-device-code` aktivieren.
Die Geräteautorisierung muss URLs nicht auf demselben Gerät geöffnet werden, auf dem Sie sich anmelden. Sie kann für Geräte mit oder ohne Browser verwendet werden.
```
If the browser does not open or you wish to use a different device to
authorize this request, open the following URL:
https://device.sso.us-west-2.amazonaws.com/
Then enter the code:
QCFK-N451
```
------
Mit dem Parameter `--sso-session` des `aws sso login`-Befehls können Sie auch angeben, welches `sso-session`-Profil bei der Anmeldung verwendet werden soll. Die Option `sso-session` ist für ältere Versionen von IAM Identity Center nicht verfügbar.
```
$ aws sso login --sso-session my-dev-session
```
Ab der Version 2.22.0 ist die PKCE-Autorisierung die Standardeinstellung. Um die Geräteautorisierung für die Anmeldung zu verwenden, fügen Sie die Option `--use-device-code` hinzu.
```
$ aws sso login --profile my-dev-profile --use-device-code
```
Das Authentifizierungstoken wird auf der Festplatte unter dem Verzeichnis `~/.aws/sso/cache` mit einem Dateinamen zwischengespeichert, der auf der `sso_start_url` basiert.
## Ausführen eines Befehls mit Ihrem Profil für IAM Identity Center
Sobald Sie angemeldet sind, können Sie Ihre Anmeldeinformationen verwenden, um AWS CLI Befehle mit dem zugehörigen benannten Profil aufzurufen. Das folgende Beispiel zeigt einen Befehl mit Verwendung eines Profils:
```
$ aws sts get-caller-identity --profile my-dev-profile
```
Solange Sie bei IAM Identity Center angemeldet sind und die zwischengespeicherten Anmeldeinformationen nicht abgelaufen sind, werden abgelaufene Anmeldeinformationen bei AWS CLI Bedarf automatisch erneuert. AWS Wenn Ihre IAM–Identity-Center-Anmeldeinformationen jedoch ablaufen, müssen Sie sie explizit erneuern, indem Sie sich erneut bei Ihrem IAM–Identity-Center-Konto anmelden.
## Abmelden von Ihren Sitzungen im IAM Identity Center
Wenn Sie Ihr Profil für IAM Identity Center nicht mehr verwenden, können Sie Ihre Anmeldeinformationen ablaufen lassen oder den folgenden Befehl ausführen, um Ihre zwischengespeicherten Anmeldeinformationen zu löschen.
```
$ aws sso logout
Successfully signed out of all SSO profiles.
```
## Fehlerbehebung
Wenn Sie bei der Verwendung von auf Probleme stoßen AWS CLI, finden Sie unter Schritte [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) zur Fehlerbehebung.
## Zugehörige Ressourcen
Die folgenden zusätzlichen Ressourcen stehen zur Verfügung.
+ [AWS IAM Identity Center-Konzepte für die AWS CLI](cli-configure-sso-concepts.md)
+ [Tutorial: Verwenden von IAM Identity Center zur Ausführung von Amazon S3 S3-Befehlen in AWS CLI](cli-configure-sso-tutorial.md)
+ [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md)
+ [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md)
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html) in der *Referenz zu AWS CLI Version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html) in der *Referenz zu AWS CLI Version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/login.html](https://docs.aws.amazon.com/cli/latest/reference/sso/login.html) in der *Referenz zu AWS CLI Version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html](https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html) in der *Referenz zu AWS CLI Version 2*
+ [Einrichtung für die Verwendung von AWS CLI with CodeCatalyst](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html) im * CodeCatalyst Amazon-Benutzerhandbuch*
+ [OAuth 2.0 Zugriffsbereiche](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) im *IAM Identity Center-Benutzerhandbuch*
+ [Tutorials für die ersten Schritte](https://docs.aws.amazon.com/singlesignon/latest/userguide/tutorials.html) im *Benutzerhandbuch zu IAM Identity Center*
# AWS IAM Identity Center-Konzepte für die AWS CLI
In diesem Thema werden die wichtigsten Konzepte von AWS IAM Identity Center (IAM Identity Center) beschrieben. IAM Identity Center ist ein cloudbasierter IAM-Service, der die Benutzerzugriffsverwaltung für mehrere AWS-Konten, Anwendungen, SDKs und Tools vereinfacht, indem er in bestehende Identitätsanbieter (IdP) integriert wird. Er ermöglicht sicheres Single Sign-On, Berechtigungsverwaltung und Auditing über ein zentrales Benutzerportal und optimiert so die Identitäts- und Zugriffsverwaltung für Unternehmen.
**Topics**
+ [Was ist das IAM Identity Center](#cli-configure-sso-concepts-what)
+ [Bedingungen](#cli-configure-sso-terms)
+ [Funktionsweise von IAM Identity Center](#cli-configure-sso-concepts-process)
+ [Weitere Ressourcen](#cli-configure-sso-concepts-resources)
## Was ist das IAM Identity Center
IAM Identity Center ist ein cloudbasierter Service für das Identitäts- und Zugriffsmanagement (IAM), mit dem Sie den Zugriff auf mehrere AWS-Konten und Geschäftsanwendungen zentral verwalten können.
Er bietet ein Benutzerportal, über das autorisierte Benutzer mit ihren vorhandenen Unternehmensanmeldeinformationen auf die AWS-Konten und Anwendungen zugreifen können, für die ihnen die entsprechenden Berechtigungen erteilt wurden. Auf diese Weise können Unternehmen konsistente Sicherheitsrichtlinien durchsetzen und die Verwaltung des Benutzerzugriffs optimieren.
Unabhängig davon, welchen IdP Sie verwenden, abstrahiert das IAM Identity Center diese Unterschiede. So können Sie beispielsweise Microsoft Azure AD wie in dem Blogartikel [The Next Evolution in IAM Identity Center](https://aws.amazon.com/blogs/aws/the-next-evolution-in-aws-single-sign-on/) beschrieben verbinden.
**Anmerkung**
Informationen zur Verwendung der Bearer-Authentifizierung, bei der keine Konto-ID und Rolle verwendet werden, finden Sie unter [Einrichtung für die Verwendung der AWS CLI mit CodeCatalyst](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html) im *Amazon-CodeCatalyst-Benutzerhandbuch*.
## Bedingungen
Im Folgenden finden Sie einige allgemeine Begriffe für die Verwendung von IAM Identity Center:
**Identitätsanbieter (IdP)**
Ein Identitätsverwaltungssystem wie IAM Identity Center, Microsoft Azure AD, Okta oder der eigene Directory Service Ihres Unternehmens.
**AWS IAM Identity Center**
IAM Identity Center ist der IdP-Service im Besitz von AWS. SDKs und Tools, die früher als AWS Single Sign-On bekannt waren, behalten die `sso`-API-Namespaces aus Gründen der Abwärtskompatibilität bei. Weitere Informationen finden Sie unter [Umbenennung von IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html#renamed) im *Benutzerhandbuch zu AWS IAM Identity Center*.
**AWS-Zugangsportal-URL, SSO-Start-URL, Start-URL**
Die eindeutige URL für das IAM Identity Center Ihres Unternehmens für den Zugriff auf Ihre autorisierten AWS-Konten, Services und Ressourcen.
**URL des Ausstellers**
Die eindeutige Aussteller-URL für das IAM Identity Center Ihres Unternehmens für den programmgesteuerten Zugriff auf Ihre autorisierten AWS-Konten, Services und Ressourcen. Ab Version 2.22.0 der AWS CLI kann die Aussteller-URL synonym mit der Start-URL verwendet werden.
**Verbund**
Der Prozess der Vertrauensbildung zwischen IAM Identity Center und einem Identitätsanbieter, um Single Sign-On (SSO) zu ermöglichen.
**AWS-Konten**
Die AWS-Konten, über die Sie Benutzern per AWS IAM Identity Center Zugriff gewähren.
**Berechtigungssätze, AWS-Anmeldeinformationen, Anmeldeinformationen, sigv4-Anmeldeinformationen**
Vordefinierte Sammlungen von Berechtigungen, die Benutzern oder Gruppen zugewiesen werden können, um ihnen Zugriff auf AWS-Services zu gewähren.
**Registrierungsbereiche, Zugriffsbereiche, Bereiche**
Bereiche sind ein Mechanismus in OAuth 2.0, um den Zugriff einer Anwendung auf ein Benutzerkonto zu beschränken. Eine Anwendung kann einen oder mehrere Bereiche anfordern und das an die Anwendung ausgegebene Zugriffstoken ist auf die gewährten Bereiche beschränkt. Weitere Informationen zu Bereichen finden Sie unter [Zugriffsbereiche](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) im *Benutzerhandbuch zu IAM Identity Center*.
**Token, Aktualisierungstoken, Zugriffstoken**
Token sind temporäre Sicherheitsnachweise, die Ihnen bei der Authentifizierung ausgestellt werden. Diese Token enthalten Informationen über Ihre Identität und die Berechtigungen, die Ihnen erteilt wurden.
Wenn Sie über das IAM Identity Center-Portal auf eine AWS-Ressource oder -Anwendung zugreifen, wird Ihr Token AWS zur Authentifizierung und Autorisierung vorgelegt. Damit kann AWS Ihre Identität überprüfen und sicherstellen, dass Sie über die erforderlichen Berechtigungen verfügen, um die angeforderten Aktionen durchzuführen.
Das Authentifizierungstoken wird auf der Festplatte unter dem Verzeichnis `~/.aws/sso/cache` mit einem JSON-Dateinamen zwischengespeichert, der auf dem Sitzungsnamen basiert.
**Sitzung**
Eine IAM Identity Center-Sitzung bezieht sich auf den Zeitraum, in dem ein Benutzer authentifiziert und autorisiert ist, auf AWS-Ressourcen oder -Anwendungen zuzugreifen. Wenn sich ein Benutzer beim IAM Identity Center-Portal anmeldet, wird eine Sitzung eingerichtet, und das Token des Benutzers ist für eine bestimmte Dauer gültig. Weitere Informationen zum Festlegen der Sitzungsdauer finden Sie unter [Festlegen der Sitzungsdauer](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html) im *Benutzerhandbuch zu AWS IAM Identity Center*.
Während der Sitzung können Sie zwischen verschiedenen AWS-Konten und -Anwendungen wechseln, ohne sich erneut authentifizieren zu müssen, solange die jeweilige Sitzung aktiv bleibt. Wenn die Sitzung abläuft, melden Sie sich erneut an, um Ihren Zugriff zu erneuern.
IAM Identity Center-Sitzungen sorgen für eine reibungslose Benutzererfahrung und setzen gleichzeitig bewährte Sicherheitsverfahren durch, indem die Gültigkeit von Anmeldeinformationen für den Benutzerzugriff eingeschränkt wird.
**Erteilung eines Autorisierungscodes mit PKCE, PKCE, Proof Key for Code Exchange**
Ab Version 2.22.0 ist Proof Key for Code Exchange (PKCE) ein OAuth 2.0-Verfahren für die Erteilung einer Authentifizierung für Geräte mit einem Browser. PKCE ist eine einfache und sichere Methode, um sich zu authentifizieren und die Zustimmung für den Zugriff auf Ihre AWS-Ressourcen von Desktops und Mobilgeräten mit Webbrowsern einzuholen. Dies ist das standardmäßige Autorisierungsverhalten. Weitere Informationen zu PKCE finden Sie unter [Erteilung eines Autorisierungscodes mit PKCE](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#auth-code-grant-pkce) im *Benutzerhandbuch zu AWS IAM Identity Center*.
**Erteilung der Geräteautorisierung**
Ein OAuth 2.0-Verfahren für die Erteilung einer Authentifizierung für Geräte mit oder ohne Webbrowser. Weitere Informationen zum Festlegen der Sitzungsdauer finden Sie unter [Erteilung der Autorisierung für Geräte](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#device-auth-grant) im *Benutzerhandbuch zu AWS IAM Identity Center*.
## Funktionsweise von IAM Identity Center
IAM Identity Center lässt sich in den Identitätsanbieter Ihres Unternehmens integrieren, z. B. IAM Identity Center, Microsoft Azure AD oder Okta. Benutzer authentifizieren sich bei diesem Identitätsanbieter und IAM Identity Center ordnet diese Identitäten dann den entsprechenden Berechtigungen und Zugriffen in Ihrer AWS-Umgebung zu.
Beim folgenden Workflow in IAM Identity Center wird davon ausgegangen, dass Sie Ihre AWS CLI bereits für die Verwendung von IAM Identity Center konfiguriert haben:
1. Führen Sie den Befehl `aws sso login` in Ihrem bevorzugten Terminal aus.
1. Melden Sie sich bei Ihrem AWS-Zugangsportal an, um eine neue Sitzung zu starten.
+ Wenn Sie eine neue Sitzung starten, erhalten Sie ein Aktualisierungstoken und ein Zugriffstoken, die zwischengespeichert werden.
+ Wenn Sie bereits eine aktive Sitzung haben, wird die bestehende Sitzung wiederverwendet und läuft ab, wenn die bestehende Sitzung abläuft.
1. Basierend auf dem Profil, das Sie in Ihrer `config`-Datei eingerichtet haben, geht IAM Identity Center von den entsprechenden Berechtigungssätzen aus und gewährt Zugriff auf die relevanten AWS-Kontenund Anwendungen.
1. Die AWS CLI, SDKs und Tools verwenden Ihre angenommene IAM-Rolle, um Aufrufe an AWS-Services durchzuführen, beispielsweise für die Erstellung von Amazon-S3-Buckets, bis diese Sitzung abläuft.
1. Das Zugriffstoken von IAM Identity Center wird stündlich überprüft und mit dem Aktualisierungstoken automatisch aktualisiert.
+ Wenn das Zugriffstoken abgelaufen ist, verwendet das SDK oder das Tool das Aktualisierungstoken, um ein neues Zugriffstoken abzurufen. Die Sitzungsdauer dieser Token wird dann verglichen. Wenn das Aktualisierungstoken nicht abgelaufen ist, stellt IAM Identity Center ein neues Zugriffstoken bereit.
+ Wenn das Aktualisierungstoken abgelaufen ist, werden keine neuen Zugriffstoken bereitgestellt und Ihre Sitzung ist beendet.
1. Sitzungen enden nach Ablauf der Aktualisierungstoken oder wenn Sie sich mithilfe des Befehls `aws sso logout` manuell abmelden. Die zwischengespeicherten Anmeldeinformationen werden entfernt. Um weiterhin über IAM Identity Center auf Services zugreifen zu können, müssen Sie mit dem Befehl `aws sso login` eine neue Sitzung starten.
## Weitere Ressourcen
Die folgenden zusätzlichen Ressourcen stehen zur Verfügung.
+ [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md)
+ [Tutorial: Verwenden von IAM Identity Center zur Ausführung von Amazon S3 S3-Befehlen in AWS CLI](cli-configure-sso-tutorial.md)
+ [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md)
+ [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md)
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html) in der *Referenz zu AWS CLI Version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html) in der *Referenz zu AWS CLI Version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/login.html](https://docs.aws.amazon.com/cli/latest/reference/sso/login.html) in der *Referenz zu AWS CLI Version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html](https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html) in der *Referenz zu AWS CLI Version 2*
+ [Einrichtung für die Verwendung der AWS CLI mit CodeCatalyst](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html) im *Benutzerhandbuch zu Amazon CodeCatalyst*
+ [Umbenennung von IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html#renamed) im *Benutzerhandbuch zu AWS IAM Identity Center*
+ [OAuth 2.0-Zugriffsbereiche](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) im *Benutzerhandbuch zu IAM Identity Center*
+ [Festlegen der Sitzungsdauer](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html) im *Benutzerhandbuch zu AWS IAM Identity Center*
+ [Tutorials für die ersten Schritte](https://docs.aws.amazon.com/singlesignon/latest/userguide/tutorials.html) im *Benutzerhandbuch zu IAM Identity Center*
# Tutorial: Verwenden von IAM Identity Center zur Ausführung von Amazon S3 S3-Befehlen in AWS CLI
In diesem Thema wird beschrieben, wie Sie die Befehle AWS CLI zur Authentifizierung von Benutzern mit aktuellen AWS IAM Identity Center (IAM Identity Center) zum Abrufen von Anmeldeinformationen zum Ausführen AWS Command Line Interface (AWS CLI) für Amazon Simple Storage Service (Amazon S3) konfigurieren.
**Topics**
+ [Schritt 1: Authentifizierung in IAM Identity Center](#cli-configure-sso-tutorial-authentication)
+ [Schritt 2: Erfassen Ihrer Informationen für IAM Identity Center](#cli-configure-sso-tutorial-gather)
+ [Schritt 3: Erstellen von Amazon-S3-Buckets](#cli-configure-sso-tutorial-buckets)
+ [Schritt 4: Installieren Sie das AWS CLI](#cli-configure-sso-tutorial-install)
+ [Schritt 5: Konfigurieren Sie Ihr AWS CLI Profil](#cli-configure-sso-tutorial-configure)
+ [Schritt 6: Anmelden bei IAM Identity Center](#cli-configure-sso-tutorial-login.title)
+ [Schritt 7: Ausführen von Amazon-S3-Befehlen](#cli-configure-sso-tutorial-commands)
+ [Schritt 8: Abmelden von IAM Identity Center](#cli-configure-sso-tutorial-logout)
+ [Schritt 9: Ressourcen bereinigen](#cli-configure-sso-tutorial-cleanup)
+ [Fehlerbehebung](#cli-configure-sso-tutorial-tshoot)
+ [Weitere Ressourcen](#cli-configure-sso-tutorial-resources.title)
## Schritt 1: Authentifizierung in IAM Identity Center
Besorgen Sie sich Zugriff auf die SSO-Authentifizierung in IAM Identity Center. Wählen Sie eine der folgenden Methoden, um auf Ihre AWS Anmeldeinformationen zuzugreifen.
### Ich habe keinen Zugriff über IAM Identity Center eingerichtet
Folgen Sie den Anweisungen unter [Erste Schritte](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) im *AWS IAM Identity Center -Benutzerhandbuch*. Dieser Prozess aktiviert IAM Identity Center, erstellt einen Administratorbenutzer und fügt einen entsprechenden Berechtigungssatz mit der geringsten Berechtigung hinzu.
**Anmerkung**
Erstellen Sie einen Berechtigungssatz, der Berechtigungen mit der geringsten Berechtigung anwendet. Wir empfehlen, den vordefinierten `PowerUserAccess`-Berechtigungssatz zu verwenden, es sei denn, Ihr Arbeitgeber hat zu diesem Zweck einen benutzerdefinierten Berechtigungssatz erstellt.
Verlassen Sie das Portal und melden Sie sich erneut an AWS-Konten, um Ihre programmatischen Zugangsdaten und Optionen für `Administrator` oder `PowerUserAccess` zu sehen. Wählen Sie `PowerUserAccess` aus, wenn Sie mit dem SDK arbeiten.
### Ich habe bereits AWS über einen von meinem Arbeitgeber verwalteten föderierten Identitätsanbieter Zugriff darauf (z. B. Azure AD oder Okta)
Melden Sie sich AWS über das Portal Ihres Identitätsanbieters an. Wenn Ihr Cloud-Administrator Ihnen `PowerUserAccess` (Entwickler-) Berechtigungen erteilt hat, sehen Sie, auf AWS-Konten welche Sie Zugriff haben, und Ihren Berechtigungssatz. Neben dem Namen Ihres Berechtigungssatzes sehen Sie Optionen für den manuellen oder programmgesteuerten Zugriff auf die Konten mithilfe dieses Berechtigungssatzes.
Benutzerdefinierte Implementierungen können zu unterschiedlichen Erfahrungen führen, z. B. zu unterschiedlichen Namen von Berechtigungssätzen. Wenn Sie sich nicht sicher sind, welchen Berechtigungssatz Sie verwenden sollen, wenden Sie sich an Ihr IT-Team.
### Ich habe bereits Zugriff auf AWS das von meinem Arbeitgeber verwaltete AWS Zugangsportal
Melden Sie sich AWS über Ihr AWS Zugangsportal an. Wenn Ihr Cloud-Administrator Ihnen `PowerUserAccess` (Entwickler-) Berechtigungen erteilt hat, sehen Sie, auf AWS-Konten welche Sie Zugriff haben, und Ihren Berechtigungssatz. Neben dem Namen Ihres Berechtigungssatzes sehen Sie Optionen für den manuellen oder programmgesteuerten Zugriff auf die Konten mithilfe dieses Berechtigungssatzes.
### Ich habe bereits AWS über einen föderierten Anbieter für benutzerdefinierte Identitäten, der von meinem Arbeitgeber verwaltet wird, Zugriff darauf
Wenden Sie sich an Ihr IT-Team, um Hilfe zu erhalten.
## Schritt 2: Erfassen Ihrer Informationen für IAM Identity Center
Nachdem Sie Zugriff auf erhalten haben AWS, sammeln Sie Ihre IAM Identity Center-Informationen, indem Sie wie folgt vorgehen:
1. Sammeln Sie Ihre `SSO Region`- und `SSO Start URL`-Werte, die Sie für die Ausführung von `aws configure sso` benötigen.
1. Wählen Sie in Ihrem AWS Zugriffsportal den Berechtigungssatz aus, den Sie für die Entwicklung verwenden, und klicken Sie **auf den Link Zugriffstasten**.
1. Wählen Sie im Dialogfeld **Anmeldeinformationen abrufen** die Registerkarte aus, die Ihrem Betriebssystem entspricht.
1. Wählen Sie die Methode **Anmeldeinformationen für IAM Identity Center** aus, um die Werte für `SSO Start URL` und `SSO Region` abzurufen.
1. Alternativ können Sie ab Version 2.22.0 die neue Aussteller-URL anstelle der Start-URL verwenden. Die Aussteller-URL befindet sich in der AWS IAM Identity Center Konsole an einem der folgenden Orte:
+ Auf der **Dashboard**-Seite finden Sie die Aussteller-URL in der Einstellungsübersicht.
+ Auf der Seite **Einstellungen** finden Sie die Aussteller-URL in den Einstellungen für die **Identitätsquelle**.
1. Informationen dazu, welcher Bereichswert registriert werden muss, finden Sie unter [OAuth 2.0 Access Scopes](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) im *IAM Identity* Center-Benutzerhandbuch.
## Schritt 3: Erstellen von Amazon-S3-Buckets
Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
Erstellen Sie für dieses Tutorial einige Buckets, die später in einer Liste abgerufen werden sollen.
## Schritt 4: Installieren Sie das AWS CLI
Installieren Sie die AWS CLI folgenden Anweisungen für Ihr Betriebssystem. Weitere Informationen finden Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md).
Nach der Installation können Sie die Installation überprüfen, indem Sie Ihr bevorzugtes Terminal öffnen und den folgenden Befehl ausführen. Dies sollte Ihre installierte Version von anzeigen AWS CLI.
```
$ aws --version
```
## Schritt 5: Konfigurieren Sie Ihr AWS CLI Profil
Konfigurieren Sie Ihr Profil mithilfe einer der folgenden Methoden:
### Konfigurieren Ihres Profils mit dem `aws configure sso`-Assistenten
Der `sso-session` Abschnitt der `config` Datei wird verwendet, um Konfigurationsvariablen für den Erwerb von SSO-Zugriffstoken zu gruppieren, die dann zum Abrufen von AWS Anmeldeinformationen verwendet werden können. Die folgenden Einstellungen werden verwendet:
+ **(Erforderlich)** `sso\$1start\$1url`
+ **(Erforderlich)** `sso\$1region`
+ `sso\$1account\$1id`
+ `sso\$1role\$1name`
+ `sso\$1registration\$1scopes`
Sie definieren einen `sso-session`-Abschnitt und ordnen ihn einem Profil zu. Die Einstellungen `sso_region` und `sso_start_url` müssen innerhalb des `sso-session`-Abschnitts festgelegt werden. Normalerweise müssen `sso_account_id` und `sso_role_name` im `profile`-Abschnitt festgelegt werden, damit das SDK SSO-Anmeldeinformationen anfordern kann.
Im folgenden Beispiel wird das SDK für die Anforderung von SSO-Anmeldeinformationen konfiguriert und es wird eine automatische Token-Aktualisierung unterstützt:
```
$ aws configure sso
SSO session name (Recommended): my-sso
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
Für die Dual-Stack-Unterstützung können Sie das Dual-Stack-SSO-Start-URL-Format verwenden:
```
$ aws configure sso
SSO session name (Recommended): my-sso
SSO start URL [None]: https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
Die Autorisierung mit Proof Key for Code Exchange (PKCE) wird ab Version 2.22.0 der AWS CLI standardmäßig verwendet und muss auf Geräten mit einem Browser genutzt werden. Um die Geräteautorisierung weiterhin zu verwenden, fügen Sie die Option `--use-device-code` hinzu.
```
$ aws configure sso --use-device-code
```
### Manuelle Konfiguration mithilfe der `config`-Datei
Der `sso-session` Abschnitt der `config` Datei wird verwendet, um Konfigurationsvariablen für den Erwerb von SSO-Zugriffstoken zu gruppieren, die dann zum Abrufen von Anmeldeinformationen verwendet werden können. AWS Die folgenden Einstellungen werden verwendet:
+ **(Erforderlich)** `sso\$1start\$1url`
+ **(Erforderlich)** `sso\$1region`
+ `sso\$1account\$1id`
+ `sso\$1role\$1name`
+ `sso\$1registration\$1scopes`
Sie definieren einen `sso-session`-Abschnitt und ordnen ihn einem Profil zu. `sso_region` und `sso_start_url` müssen innerhalb des `sso-session`-Abschnitts festgelegt werden. Normalerweise müssen `sso_account_id` und `sso_role_name` im `profile`-Abschnitt festgelegt werden, damit das SDK SSO-Anmeldeinformationen anfordern kann.
Im folgenden Beispiel wird das SDK für die Anforderung von SSO-Anmeldeinformationen konfiguriert und es wird eine automatische Token-Aktualisierung unterstützt:
```
[profile my-dev-profile]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_registration_scopes = sso:account:access
```
Verwenden Sie für Dual-Stack-Unterstützung das Dual-Stack-SSO-Start-URL-Format:
```
[profile my-dev-profile]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_registration_scopes = sso:account:access
```
Das Authentifizierungs-Token wird auf der Festplatte unter dem Verzeichnis `~/.aws/sso/cache` mit einem Dateinamen zwischengespeichert, der auf dem Sitzungsnamen basiert.
## Schritt 6: Anmelden bei IAM Identity Center
**Anmerkung**
Während des Anmeldevorgangs werden Sie möglicherweise aufgefordert, den AWS CLI Zugriff auf Ihre Daten zu gewähren. Da AWS CLI das auf dem SDK für Python aufbaut, können Berechtigungsnachrichten Variationen des `botocore` Namens enthalten.
Um Ihre Anmeldeinformationen für IAM Identity Center abzurufen und zwischenzuspeichern, führen Sie den folgenden Befehl für die AWS CLI aus, um Ihren Standardbrowser zu öffnen und Ihre Anmeldung bei IAM Identity Center zu überprüfen.
```
$ aws sso login --profile my-dev-profile
```
Ab der Version 2.22.0 ist die PKCE-Autorisierung die Standardeinstellung. Um die Geräteautorisierung für die Anmeldung zu verwenden, fügen Sie die Option `--use-device-code` hinzu.
```
$ aws sso login --profile my-dev-profile --use-device-code
```
## Schritt 7: Ausführen von Amazon-S3-Befehlen
Verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html), um die Buckets aufzulisten, die Sie zuvor erstellt haben. Das folgende Beispiel listet alle Ihre Amazon-S3-Buckets auf.
```
$ aws s3 ls
2018-12-11 17:08:50 my-bucket
2018-12-14 14:55:44 my-bucket2
```
## Schritt 8: Abmelden von IAM Identity Center
Wenn Sie Ihr Profil für IAM Identity Center nicht mehr verwenden, führen Sie den folgenden Befehl aus, um Ihre zwischengespeicherten Anmeldeinformationen zu löschen.
```
$ aws sso logout
Successfully signed out of all SSO profiles.
```
## Schritt 9: Ressourcen bereinigen
Wenn Sie mit diesem Tutorial fertig sind, bereinigen Sie alle Ressourcen, die Sie in diesem Tutorial erstellt haben und nicht mehr benötigen, einschließlich Amazon-S3-Buckets.
## Fehlerbehebung
Wenn Sie bei der Verwendung von auf Probleme stoßen AWS CLI, finden Sie unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) Allgemeine Schritte zur Fehlerbehebung.
## Weitere Ressourcen
Die folgenden zusätzlichen Ressourcen stehen zur Verfügung.
+ [AWS IAM Identity Center-Konzepte für die AWS CLI](cli-configure-sso-concepts.md)
+ [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md)
+ [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md)
+ [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md)
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html) in der *Referenz zu AWS CLI Version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html) in der *Referenz zu AWS CLI Version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/login.html](https://docs.aws.amazon.com/cli/latest/reference/sso/login.html) in der *Referenz zu AWS CLI Version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html](https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html) in der *Referenz zu AWS CLI Version 2*
+ [Einrichtung für die Verwendung von AWS CLI with CodeCatalyst](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html) im * CodeCatalyst Amazon-Benutzerhandbuch*
+ [OAuth 2.0 Zugriffsbereiche](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) im *IAM Identity Center-Benutzerhandbuch*
+ [Tutorials für die ersten Schritte](https://docs.aws.amazon.com/singlesignon/latest/userguide/tutorials.html) im *Benutzerhandbuch zu IAM Identity Center*
# Authentifizierung mit kurzfristigen Zugangsdaten für den AWS CLI
Wir empfehlen, Ihr SDK oder Tool so zu konfigurieren, dass die [Authentifizierung von IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) mit Optionen für die verlängerte Sitzungsdauer verwendet wird. Sie können jedoch temporäre Anmeldeinformationen, die im AWS Access Portal verfügbar sind, kopieren und verwenden. Wenn diese Anmeldeinformationen ablaufen, müssen neue kopiert werden. Sie können die temporären Anmeldeinformationen in einem Profil verwenden oder sie als Werte für Systemeigenschaften und Umgebungsvariablen verwenden.
1. [Melden Sie sich beim AWS Access-Portal](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html) an.
1. Folgen Sie [diesen Anweisungen](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html), um die Anmeldeinformationen für die IAM-Rolle aus dem AWS Zugriffsportal zu kopieren.
1. Wählen Sie für Schritt 2 der verlinkten Anleitung das AWS Konto und den Namen der IAM-Rolle aus, die den Zugriff für Ihre Entwicklungsanforderungen gewähren. Diese Rolle hat normalerweise einen Namen wie **PowerUserAccess**oder **Developer**.
1. Wählen Sie für Schritt 4 die Option **Profil zu Ihrer AWS -Anmeldeinformationsdatei hinzufügen** aus und kopieren Sie den Inhalt.
1. Erstellen oder öffnen Sie die freigegebene `credentials`-Datei. Diese Datei befindet sich in Linux- und macOS-Systemen im Pfad `~/.aws/credentials` und unter Windows im Pfad `%USERPROFILE%\.aws\credentials`. Weitere Informationen finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
1. Fügen Sie der freigegebenen `credentials`-Datei den folgenden Text hinzu. Ersetzen Sie die Beispielwerte durch die kopierten Anmeldeinformationen.
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
1. Fügen Sie der freigegebenen `config`-Datei Ihre bevorzugte Standardregion und Ihr bevorzugtes Standardformat hinzu.
```
[default]
region=us-west-2
output=json
[profile user1]
region=us-east-1
output=text
```
Wenn das SDK einen Service-Client erstellt, greift es auf diese temporären Anmeldeinformationen zu und verwendet sie für jede Anfrage. Die in Schritt 2a ausgewählten Einstellungen für die IAM-Rolle bestimmen, [wie lange die temporären Anmeldeinformationen gültig sind](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html). Die maximale Dauer beträgt zwölf Stunden.
Wiederholen Sie diese Schritte jedes Mal, wenn Ihre Anmeldeinformationen ablaufen.
# Verwenden einer IAM-Rolle in der AWS CLI
Eine [AWS Identity and Access Management (IAM-) Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) ist ein Autorisierungstool, mit dem ein Benutzer zusätzliche (oder andere) Berechtigungen oder Berechtigungen zum Ausführen von Aktionen in einem anderen AWS Konto erhält.
**Topics**
+ [Voraussetzungen](#cli-role-prereqs)
+ [Überblick über die Verwendung von IAM-Rollen](#cli-role-overview)
+ [Konfigurieren und Verwenden einer Rolle](#cli-role-prepare)
+ [Verwenden von Multi-Factor Authentication (MFA)](#cli-configure-role-mfa)
+ [Kontenübergreifende Rollen und externe ID](#cli-configure-role-xaccount)
+ [Angeben eines Rollensitzungsnamens für eine einfachere Prüfung](#cli-configure-role-session-name)
+ [Übernehmen einer Rolle mit Web-Identität](#cli-configure-role-oidc)
+ [Anmeldeinformationen aus dem Cache löschen](#cli-configure-role-cache)
## Voraussetzungen
Wenn Sie diese `iam`-Befehle verwenden möchten, müssen Sie die AWS CLI installieren und konfigurieren. Dazu gehört die Einrichtung eines konfigurierten Profils, da davon ausgegangen wird, dass eine Rolle mit einer anderen Methode für Anmeldeinformationen kombiniert wird. Weitere Informationen finden Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md).
## Überblick über die Verwendung von IAM-Rollen
Sie können AWS Command Line Interface (AWS CLI) für die Verwendung einer IAM-Rolle konfigurieren, indem Sie ein Profil für die Rolle in der `~/.aws/config` Datei definieren.
Im folgenden Beispiel sehen Sie ein Rollenprofil namens `marketingadmin`. Wenn Sie Befehle mit ausführen `--profile marketingadmin` (oder sie mit der [AWS\$1PROFILE Umgebungsvariablen](cli-configure-envvars.md) angeben), AWS CLI verwendet der die in einem separaten Profil definierten Anmeldeinformationen, `user1` um die Rolle mit dem Amazon-Ressourcennamen (ARN) anzunehmen`arn:aws:iam::123456789012:role/marketingadminrole`. Sie können alle Operationen ausführen, die gemäß den der Rolle zugewiesenen Berechtigungen zulässig sind.
```
[profile marketingadmin]
role_arn = arn:aws:iam::123456789012:role/marketingadminrole
source_profile = user1
```
Sie können dann ein `source_profile` angeben, das auf ein separates benanntes Profil zeigt, welches Benutzer-Anmeldeinformationen mit der Berechtigung zur Verwendung der Rolle enthält. Im vorherigen Beispiel verwendet das Profil `marketingadmin` die Anmeldeinformationen im Profil `user1`. Wenn Sie angeben, dass ein AWS CLI Befehl das Profil verwenden soll`marketingadmin`, sucht das AWS CLI automatisch nach den Anmeldeinformationen für das verknüpfte `user1` Profil und verwendet sie, um temporäre Anmeldeinformationen für die angegebene IAM-Rolle anzufordern. Die CLI verwendet die [sts: AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) -Operation im Hintergrund, um dies zu erreichen. Diese temporären Anmeldeinformationen werden dann verwendet, um den angeforderten AWS CLI -Befehl ausführen. Der angegebenen Rolle müssen IAM-Berechtigungsrichtlinien angehängt sein, die die Ausführung des angeforderten AWS CLI Befehls ermöglichen.
Um einen AWS CLI Befehl in einer Amazon Elastic Compute Cloud (Amazon EC2) -Instance oder einem Amazon Elastic Container Service (Amazon ECS) -Container auszuführen, können Sie eine IAM-Rolle verwenden, die dem Instance-Profil oder dem Container zugewiesen ist. Wenn Sie kein Profil angeben oder keine Umgebungsvariablen festlegen, wird diese Rolle direkt verwendet. So müssen Sie keine Langzeit-Zugriffsschlüssel in Ihren Instances speichern. Sie können diese Instance- oder Container-Rollen auch verwenden, um Anmeldeinformationen für eine andere Rolle abzurufen. Zu diesem Zweck verwenden Sie `credential_source` (anstelle von `source_profile`), um anzugeben, wie die Anmeldeinformationen zu finden sind. Das Attribut `credential_source` unterstützt die folgenden Werte:
+ `Environment` – Um die Quell-Anmeldeinformationen aus Umgebungsvariablen abzurufen.
+ `Ec2InstanceMetadata` – Verwendet die IAM-Rolle, die dem Amazon-EC2-Instance-Profil zugeordnet ist.
+ `EcsContainer` – Verwendet die IAM-Rolle, die dem Amazon-ECS-Container zugeordnet ist.
Das folgende Beispiel zeigt dieselbe `marketingadminrole`-Rolle, die durch Referenzieren eines Amazon-EC2-Instance-Profils verwendet wurde.
```
[profile marketingadmin]
role_arn = arn:aws:iam::123456789012:role/marketingadminrole
credential_source = Ec2InstanceMetadata
```
Wenn Sie eine Rolle aufrufen, stehen Ihnen zusätzliche Optionen zur Verfügung, die Sie anfordern können, z. B. die Verwendung einer Multifaktor-Authentifizierung und einer externen ID (die von Drittanbietern für den Zugriff auf die Ressourcen ihrer Kunden verwendet wird). Sie können auch eindeutige Namen für Rollensitzungen angeben, die einfacher in Protokollen geprüft werden können. AWS CloudTrail
## Konfigurieren und Verwenden einer Rolle
Wenn Sie Befehle mit einem Profil ausführen, das eine IAM-Rolle angibt, AWS CLI verwendet das die Anmeldeinformationen des Quellprofils, um AWS -Security-Token-Service (AWS STS) aufzurufen und temporäre Anmeldeinformationen für die angegebene Rolle anzufordern. Der Benutzer im Quellprofil muss über die Berechtigung zum Aufrufen von `sts:assume-role` für die Rolle im angegebenen Profil verfügen. Die Rolle muss über eine Vertrauensstellung verfügen, die es dem Benutzer im Quellprofil ermöglicht, die Rolle zu übernehmen. Der Prozess des Abrufens mit anschließendem Verwenden von temporären Anmeldeinformationen für eine Rolle wird oft als *Annehmen der Rolle* bezeichnet.
Sie können mit den Berechtigungen in IAM eine Rolle erstellen, die Benutzer annehmen sollen, indem Sie die Anweisungen unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) im *AWS Identity and Access Management -Benutzerhandbuch* befolgen. Wenn die Rolle und der -Benutzer des Quellprofils im selben Konto vorhanden sind, können Sie beim Konfigurieren der Vertrauensstellung der Rolle Ihre eigene Konto-ID eingeben.
Nachdem Sie die Rolle erstellt haben, ändern Sie die Vertrauensstellung, um die Übernahme durch den -Benutzer zuzulassen.
Im folgenden Beispiel sehen Sie eine Vertrauensrichtlinie, die Sie einer Rolle anfügen könnten. Mit dieser Richtlinie kann die Rolle von jedem Benutzer im Konto 123456789012 angenommen werden, ***falls*** der Administrator des Kontos dem Benutzer explizit die Berechtigung `sts:AssumeRole` erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Die Vertrauensrichtlinie selbst gewährt keine Berechtigungen. Der Administrator des Kontos muss die Berechtigung zur Übernahme der Rolle an einzelne Benutzer delegieren, indem eine Richtlinie mit den entsprechenden Berechtigungen angefügt wird. Das folgende Beispiel zeigt eine Richtlinie, die Sie einem Benutzer anfügen können und mit der der Benutzer nur die Rolle `marketingadminrole` annehmen kann. Weitere Informationen, wie Sie einem Benutzer Zugriff erteilen können, damit dieser eine Rolle annehmen kann, finden Sie im Abschnitt [Erteilen von Berechtigungen an einen Benutzer zum Wechseln von Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_permissions-to-switch.html) im *IAM-Benutzerhandbuch*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::123456789012:role/marketingadminrole"
}
]
}
```
------
Der Benutzer benötigt keine zusätzlichen Berechtigungen, um die AWS CLI Befehle mithilfe des Rollenprofils auszuführen. Die Berechtigungen zum Ausführen des Befehls entstammen aus den der *Rolle* angefügten Berechtigungen. Sie fügen der Rolle Berechtigungsrichtlinien hinzu, um anzugeben, welche Aktionen für welche AWS Ressourcen ausgeführt werden können. Weitere Informationen zum Anfügen von Berechtigungen zu einer Rolle (funktioniert wie bei einem Benutzer) finden Sie unter [Ändern von Berechtigungen für einen IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) im *IAM-Benutzerhandbuch*.
Nachdem Sie nun das Rollenprofil, die Rollenberechtigungen, die Rollen-Vertrauensstellung und die Benutzerberechtigungen konfiguriert haben, können Sie die Rolle an der Befehlszeile verwenden, indem Sie die Option `--profile` aufrufen. Beispiel: Der folgende Befehl ruft den Amazon-S3-Befehl `ls` mit den Berechtigungen auf, die an die `marketingadmin`-Rolle angefügt sind, wie im Beispiel zu Beginn dieses Themas angegeben.
```
$ aws s3 ls --profile marketingadmin
```
Um die Rolle für mehrere Aufrufe zu verwenden, können Sie die Umgebungsvariable `AWS_PROFILE` für die aktuelle Sitzung über die Befehlszeile festlegen. Da die Umgebungsvariable definiert ist, müssen Sie die Option `--profile` nicht bei jedem Befehl angeben.
**Linux oder macOS**
```
$ export AWS_PROFILE=marketingadmin
```
**Windows**
```
C:\> setx AWS_PROFILE marketingadmin
```
Weitere Informationen zum Konfigurieren von Benutzern und Rollen finden Sie unter [IAM-Identitäten (Benutzer, Gruppen und Rollen)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) und unter [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id-roles.html) im *IAM-Benutzerhandbuch*.
## Verwenden von Multi-Factor Authentication (MFA)
Zur Erhöhung der Sicherheit können Sie festlegen, dass die Benutzer einen von einem Multifaktor-Authentifizierungsgerät (MFA), einem U2F-Gerät oder einen von einer mobilen App generierten einmaligen Schlüssel bereitstellen müssen, wenn sie versuchen, einen Aufruf mit dem Rollenprofil zu senden.
Zunächst können Sie die Vertrauensstellung für die IAM-Rolle so ändern, dass eine MFA erforderlich ist. Dadurch wird verhindert, dass Benutzer die Rolle verwenden, ohne sich zuerst mithilfe von MFA zu authentifizieren. Ein Beispiel finden Sie im folgenden Code in der Zeile `Condition`. Diese Richtlinie ermöglicht es dem Benutzer namens `anika`, die Rolle zu übernehmen, an die die Richtlinie angefügt ist, allerdings nur, wenn die Authentifizierung mithilfe von MFA erfolgt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:user/anika" },
"Action": "sts:AssumeRole",
"Condition": { "Bool": { "aws:multifactorAuthPresent": true } }
}
]
}
```
------
Fügen Sie als Nächstes dem Rollenprofil, das den ARN vom MFA-Gerät des Benutzers angibt, eine Zeile hinzu. In den folgenden Einträgen der Beispieldatei `config` verwenden zwei Rollenprofile die Zugriffsschlüssel für den Benutzer `anika`, um temporäre Anmeldeinformationen für die Rolle `cli-role` anzufordern. Der Benutzer `anika` hat die Berechtigung, die Rolle zu übernehmen. Sie wird ihm von der Vertrauensrichtlinie der Rolle erteilt.
```
[profile role-without-mfa]
region = us-west-2
role_arn= arn:aws:iam::128716708097:role/cli-role
source_profile=cli-user
[profile role-with-mfa]
region = us-west-2
role_arn= arn:aws:iam::128716708097:role/cli-role
source_profile = cli-user
mfa_serial = arn:aws:iam::128716708097:mfa/cli-user
[profile cli-user]
region = us-west-2
output = json
```
Die Einstellung `mfa_serial` kann einen ARN (wie gezeigt) oder die Seriennummer eines Hardware-MFA-Tokens annehmen.
Das erste Profil, `role-without-mfa`, erfordert keine MFA. Da bei dem vorherigen Beispiel die an die Rolle angefügte Vertrauensrichtlinie eine MFA erfordert, schlägt jeder Versuch, einen Befehl mit diesem Profil auszuführen, fehl.
```
$ aws iam list-users --profile role-without-mfa
An error occurred (AccessDenied) when calling the AssumeRole operation: Access denied
```
Der zweite Profileintrag, `role-with-mfa`, gibt ein MFA-Gerät an, das verwendet werden soll. Wenn der Benutzer versucht, einen AWS CLI Befehl mit diesem Profil auszuführen, AWS CLI fordert er den Benutzer auf, das vom MFA-Gerät bereitgestellte Einmalkennwort (OTP) einzugeben. Wenn die MFA-Authentifizierung erfolgreich ist, führt der Befehl den angeforderten Vorgang aus. Das Einmalkennwort wird nicht auf dem Bildschirm angezeigt.
```
$ aws iam list-users --profile role-with-mfa
Enter MFA code for arn:aws:iam::123456789012:mfa/cli-user:
{
"Users": [
{
...
```
## Kontenübergreifende Rollen und externe ID
Sie können -Benutzern ermöglichen, Rollen zu verwenden, die zu verschiedenen Konten gehören, indem Sie kontenübergreifende Rollen konfigurieren. Während der Erstellung der Rolle legen Sie den Rollentyp auf **Ein anderes AWS -Konto** fest, wie in [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) beschrieben. Wählen Sie optional **Require MFA (MFA erforderlich)** aus. Die Option **Require MFA (MFA erforderlich)** konfiguriert die zutreffende Bedingung in der Vertrauensstellung wie unter [Verwenden von Multi-Factor Authentication (MFA)](#cli-configure-role-mfa) beschrieben.
Wenn Sie eine [externe ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) verwenden, um besser zu kontrollieren, wer eine kontenübergreifende Rolle verwenden kann, müssen Sie auch den Parameter `external_id` zum Rollenprofil hinzufügen. Normalerweise verwenden Sie dieses nur, wenn das andere Konto von einer Person außerhalb Ihres Unternehmens kontrolliert wird.
```
[profile crossaccountrole]
role_arn = arn:aws:iam::234567890123:role/SomeRole
source_profile = default
mfa_serial = arn:aws:iam::123456789012:mfa/saanvi
external_id = 123456
```
## Angeben eines Rollensitzungsnamens für eine einfachere Prüfung
Wenn viele Personen eine Rolle gemeinsam nutzen, wird die Prüfung zu einer größeren Herausforderung. Sie möchten jede aufgerufene Operation mit der Person verknüpfen, die diese Aktion aufgerufen hat. Wenn die Person jedoch eine Rolle verwendet, ist die Annahme der Rolle durch die Person eine vom Aufrufen einer Operation getrennte Aktion und Sie müssen die beiden manuell korrelieren.
Sie können dies vereinfachen, indem Sie eindeutige Rollensitzungsnamen angeben, wenn Benutzer eine Rolle annehmen. Dazu fügen Sie jedem benannten Profil in der Datei `config`, die eine Rolle angibt, einen `role_session_name`-Parameter hinzu. Der Wert `role_session_name` wird an die Operation `AssumeRole` übergeben und wird Teil des ARN für die Rollensitzung. Es ist auch in den AWS CloudTrail Protokollen für alle protokollierten Vorgänge enthalten.
Sie können beispielsweise folgendermaßen ein rollenbasiertes Profil erstellen.
```
[profile namedsessionrole]
role_arn = arn:aws:iam::234567890123:role/SomeRole
source_profile = default
role_session_name = Session_Maria_Garcia
```
Dies führt dazu, dass die Rollensitzung den folgenden ARN hat.
```
arn:aws:iam::234567890123:assumed-role/SomeRole/Session_Maria_Garcia
```
Außerdem enthalten alle AWS CloudTrail Protokolle den Namen der Rollensitzung in den für jeden Vorgang erfassten Informationen.
## Übernehmen einer Rolle mit Web-Identität
Sie können ein Profil so konfigurieren, dass es angibt, dass sie mithilfe von [Web Identity Federation und Open ID Connect (OIDC](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html)) eine Rolle übernehmen AWS CLI sollen. Wenn Sie dies in einem Profil angeben, führt der AWS CLI automatisch den entsprechenden AWS STS `AssumeRoleWithWebIdentity` Anruf für Sie durch.
**Anmerkung**
Wenn Sie ein Profil angeben, das eine IAM-Rolle verwendet, werden die AWS CLI entsprechenden Aufrufe ausgeführt, um temporäre Anmeldeinformationen abzurufen. Diese Anmeldeinformationen werden in `~/.aws/cli/cache` gespeichert. Nachfolgende AWS CLI Befehle, die dasselbe Profil angeben, verwenden die zwischengespeicherten temporären Anmeldeinformationen, bis sie ablaufen. Zu diesem Zeitpunkt werden die AWS CLI Anmeldeinformationen automatisch aktualisiert.
Um mithilfe des Web-Identitätsverbunds temporäre Anmeldeinformationen abzurufen und zu verwenden, können Sie die folgenden Konfigurationswerte in einem freigegebenen Profil angeben.
[role\$1arn](#cli-configure-role)
Gibt den ARN der Rolle an, die angenommen werden soll.
web\$1identity\$1token\$1file
Gibt den Pfad zu einer Datei an, die ein OAuth 2.0-Zugriffstoken oder ein OpenID Connect-ID-Token enthält, das vom Identitätsanbieter bereitgestellt wird. Die AWS CLI lädt diese Datei und übergibt den Inhalt als `WebIdentityToken`-Argument an die Operation `AssumeRoleWithWebIdentity`.
[role\$1session\$1name](#cli-configure-role-session-name)
Gibt einen optionalen Namen an, der auf diese Rollenübernahme-Sitzung angewendet wird.
Unten finden Sie eine Beispielkonfiguration für den mindestens erforderlichen Umfang einer Konfiguration für eine angenommene Rolle mit Web-Identitätsprofil.
```
# In ~/.aws/config
[profile web-identity]
role_arn=arn:aws:iam:123456789012:role/RoleNameToAssume
web_identity_token_file=/path/to/a/token
```
Sie können diese Konfiguration auch mithilfe von [Umgebungsvariablen](cli-configure-envvars.md) bereitstellen.
AWS\$1ROLE\$1ARN
Der ARN der zu übernehmenden Rolle
AWS\$1WEB\$1IDENTITY\$1TOKEN-DATEI
Der Pfad zur Datei mit dem Web-Identitäts-Token.
AWS\$1ROLE\$1SITZUNGSNAME
Der Name für diese Sitzung der Rollenübernahme.
**Anmerkung**
Diese Umgebungsvariablen gelten derzeit nur für die Anbieter für Rollenübernahme mit Web-Identität. Sie gelten nicht für die allgemeine Konfiguration für einen Anbieter für Rollenübernahme.
## Anmeldeinformationen aus dem Cache löschen
Wenn Sie eine Rolle verwenden, werden die temporären Anmeldeinformationen lokal AWS CLI zwischengespeichert, bis sie ablaufen. Wenn Sie das nächste Mal versuchen, sie zu verwenden, wird AWS CLI versucht, sie in Ihrem Namen zu erneuern.
Wenn die temporären Anmeldeinformationen Ihrer Rolle [widerrufen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_revoke-sessions.html) werden, werden sie nicht automatisch erneuert und Versuche, sie zu verwenden, schlagen fehl. Sie können den Cache jedoch löschen, um das Abrufen neuer Anmeldeinformationen AWS CLI zu erzwingen.
**Linux oder macOS**
```
$ rm -r ~/.aws/cli/cache
```
**Windows**
```
C:\> del /s /q %UserProfile%\.aws\cli\cache
```
# Authentifizierung mit IAM-Benutzeranmeldedaten für AWS CLI
**Warnung**
Um Sicherheitsrisiken zu vermeiden, sollten Sie IAM-Benutzer nicht zur Authentifizierung verwenden, wenn Sie speziell 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).
Dieser Abschnitt erklärt, wie die grundlegende Einstellungen mit einem IAM-Benutzer konfiguriert werden. Dazu gehören Ihre Sicherheitsanmeldeinformationen unter Verwendung der Dateien `config` und `credentials`. Wenn Sie sich stattdessen die Konfigurationsanweisungen für AWS IAM Identity Center ansehen möchten, beachten Sie den Abschnitt [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md).
**Contents**
+ [Schritt 1: Erstellen Ihres IAM-Benutzers](#cli-authentication-user-create)
+ [Schritt 2: Abrufen Ihrer Zugriffsschlüssel](#cli-authentication-user-get)
+ [Schritt 3: Konfigurieren Sie AWS CLI](#cli-authentication-user-configure.title)
+ [Verwenden von `aws configure`](#cli-authentication-user-configure-wizard)
+ [Importieren von Zugriffsschlüsseln per CSV-Datei](#cli-authentication-user-configure-csv)
+ [Direktes Bearbeiten der Dateien `config` und `credentials`](#cli-authentication-user-configure-csv.titlecli-authentication-user-configure-file)
+ [(Optional) Verwenden Sie die Multi-Faktor-Authentifizierung mit Ihren IAM-Benutzeranmeldedaten](#cli-authentication-user-configure-csv.titlecli-authentication-user-mfa)
## Schritt 1: Erstellen Ihres IAM-Benutzers
Erstellen Sie Ihren IAM-Benutzer, indem Sie das Verfahren [Erstellen von IAM-Benutzern (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) im *IAM-Benutzerhandbuch* befolgen.
+ Wählen Sie unter **Berechtigung-Optionen** mit der Option **Direktes Anfügen von Richtlinien** aus, wie Sie diesem Benutzer Berechtigungen zuweisen möchten.
+ Die meisten SDK-Tutorials zum Thema „Erste Schritte“ verwenden den Amazon-S3-Service als Beispiel. Wenn Sie Ihrer Anwendung Vollzugriff auf Amazon S3 gewähren möchten, wählen Sie die `AmazonS3FullAccess`-Richtlinie zum Anfügen an diesen Benutzer aus.
## Schritt 2: Abrufen Ihrer Zugriffsschlüssel
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-Konsole **Benutzer** und dann den **`User name`** des Benutzers aus, den Sie zuvor erstellt haben.
1. Wählen Sie auf der Seite des Benutzers die Seite **Sicherheitsanmeldeinformationen** aus. Wählen Sie dann unter **Zugriffsschlüssel** die Option **Zugriffsschlüssel erstellen** aus.
1. Wählen Sie für **Zugriffsschlüssel erstellen – Schritt 1** die Option **Befehlszeilenschnittstelle (CLI)** aus.
1. Geben Sie für **Zugriffsschlüssel erstellen – Schritt 2** ein optionales Tag ein und wählen Sie **Weiter** aus.
1. Wählen Sie unter **Zugriffsschlüssel erstellen – Schritt 3** die Option **CSV-Datei herunterladen** aus, um eine `.csv`-Datei mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel Ihres IAM-Benutzers zu speichern. Sie benötigen diese Informationen später wieder.
1. Wählen Sie Done (Fertig).
## Schritt 3: Konfigurieren Sie AWS CLI
Für den allgemeinen Gebrauch AWS CLI benötigt er die folgenden Informationen:
+ Zugriffsschlüssel-ID
+ Geheimer Zugriffsschlüssel
+ AWS Region
+ Ausgabeformat
Die AWS CLI speichert diese Informationen in einem *Profil* (einer Sammlung von Einstellungen), das `default` in der `credentials` Datei benannt ist. Standardmäßig werden die Informationen in diesem Profil verwendet, wenn Sie einen AWS CLI Befehl ausführen, der nicht explizit ein zu verwendendes Profil angibt. Weitere Informationen zur `credentials`-Datei finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
Verwenden Sie eines der folgenden Verfahren AWS CLI, um das zu konfigurieren:
**Topics**
+ [Verwenden von `aws configure`](#cli-authentication-user-configure-wizard)
+ [Importieren von Zugriffsschlüsseln per CSV-Datei](#cli-authentication-user-configure-csv)
+ [Direktes Bearbeiten der Dateien `config` und `credentials`](#cli-authentication-user-configure-csv.titlecli-authentication-user-configure-file)
### Verwenden von `aws configure`
Für den allgemeinen Gebrauch ist der `aws configure` Befehl der schnellste Weg, Ihre AWS CLI Installation einzurichten. Dieser Konfigurationsassistent fordert Sie auf, alle Informationen einzugeben, die Sie für die ersten Schritte benötigen. Sofern mit der `--profile` Option nicht anders angegeben, AWS CLI speichert der diese Informationen im `default` Profil.
Im folgenden Beispiel wird ein `default`-Profil anhand von Beispielwerten konfiguriert. Ersetzen Sie sie durch eigene Werte, wie in den folgenden Abschnitten beschrieben.
```
$ aws configure
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json
```
Im folgenden Beispiel wird ein Profil mit dem Namen `userprod` anhand von Beispielwerten konfiguriert. Ersetzen Sie sie durch eigene Werte, wie in den folgenden Abschnitten beschrieben.
```
$ aws configure --profile userprod
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json
```
### Importieren von Zugriffsschlüsseln per CSV-Datei
Anstatt `aws configure` zu verwenden, um Zugriffsschlüssel einzugeben, können Sie die `.csv`-Klartextdatei importieren, die Sie nach dem Erstellen Ihrer Zugriffsschlüssel heruntergeladen haben.
Die `.csv`-Datei muss die folgenden Header enthalten.
+ Benutzername – Diese Spalte muss zu Ihrem `.csv` hinzugefügt werden. Dies wird verwendet, um den Profilnamen zu erstellen, der beim Import in den Dateien `config` und `credentials` verwendet wird.
+ Zugriffsschlüssel-ID
+ Geheimer Zugriffsschlüssel
**Anmerkung**
Während der anfänglichen Erstellung der Zugriffsschlüssel können Sie nach dem Schließen des Dialogfelds **CSV-Datei herunterladen** nicht mehr auf Ihren geheimen Zugriffsschlüssel zugreifen. Wenn Sie eine `.csv`-Datei benötigen, müssen Sie selbst eine mit den erforderlichen Headern und Ihren gespeicherten Zugriffsschlüsselinformationen erstellen. Wenn Sie keinen Zugriff auf Zugriffsschlüsselinformationen haben, müssen Sie neue Zugriffsschlüssel erstellen.
Sie importieren die `.csv`-Datei wie folgt mithilfe des `aws configure import`-Befehls mit der `--csv`-Option:
```
$ aws configure import --csv file://credentials.csv
```
Weitere Informationen finden Sie unter `aws\$1configure\$1import`.
### Direktes Bearbeiten der Dateien `config` und `credentials`
Gehen Sie wie folgt vor, um die Dateien `config` und `credentials` direkt zu bearbeiten.
1. Erstellen oder öffnen Sie die freigegebene AWS `credentials`-Datei. Diese Datei befindet sich in Linux- und macOS-Systemen im Pfad `~/.aws/credentials` und unter Windows im Pfad `%USERPROFILE%\.aws\credentials`. Weitere Informationen finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
1. Fügen Sie der freigegebenen `credentials`-Datei den folgenden Text hinzu. Ersetzen Sie die Beispielwerte in der `.csv`-Datei, die Sie zuvor heruntergeladen haben, und speichern Sie die Datei.
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
## (Optional) Verwenden Sie die Multi-Faktor-Authentifizierung mit Ihren IAM-Benutzeranmeldedaten
Für zusätzliche Sicherheit können Sie einen einmaligen Schlüssel verwenden, der von einem Multi-Faktor-Authentifizierungsgerät (MFA), einem U2F-Gerät oder einer mobilen App generiert wurde, wenn Sie versuchen, einen Anruf zu tätigen.
Wenn Ihr MFA-fähiger IAM-Benutzer ist, führen Sie den [https://docs.aws.amazon.com/cli/latest/reference/configure/mfa-login.html](https://docs.aws.amazon.com/cli/latest/reference/configure/mfa-login.html)Befehl aus, um ein neues Profil zur Verwendung mit Multi-Faktor-Authentifizierung (MFA) für das angegebene Profil zu konfigurieren. Wenn kein Profil angegeben ist, basiert die MFA auf dem `default` Profil. Wenn kein Standardprofil konfiguriert ist, werden Sie mit dem `mfa-login` Befehl zur Eingabe Ihrer AWS Anmeldeinformationen aufgefordert, bevor Sie nach Ihren MFA-Informationen gefragt werden. Das folgende Befehlsbeispiel verwendet Ihre Standardkonfiguration und erstellt ein MFA-Profil.
```
$ aws configure mfa-login
MFA serial number or ARN: arn:aws:iam::123456789012:mfa/MFADeviceName
MFA token code: 123456
Profile to update [session-MFADeviceName]:
Temporary credentials written to profile 'session-MFADeviceName'
Credentials will expire at 2023-05-19 18:06:10 UTC
To use these credentials, specify --profile session-MFADeviceName when running AWS CLI commands
```
Verwenden Sie den `--update-profile` Parameter, um ein vorhandenes Profil zu aktualisieren.
```
$ aws configure mfa-login --profile myprofile --update-profile mfaprofile
MFA token code: 123456
Temporary credentials written to profile 'mfaprofile'
Credentials will expire at 2023-05-19 18:06:10 UTC
To use these credentials, specify --profile mfaprofile when running AWS CLI commands
```
Dieser Befehl unterstützt derzeit nur hardware- oder softwarebasierte Einmalkennwort-Authentifikatoren (OTP). Passkeys und U2F-Geräte werden derzeit mit diesem Befehl nicht unterstützt.
Um Ihr MFA-Profil zu verwenden, verwenden Sie die `--profile` Option zusammen mit Ihren Befehlen.
```
$ aws s3 ls --profile mfaprofile
```
*Weitere Informationen zur Verwendung von MFA mit IAM, einschließlich der Zuweisung von MFA zu einem IAM-Benutzer, finden Sie unter [AWS Multi-Faktor-Authentifizierung in IAM im](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa.html) Benutzerhandbuch.AWS Identity and Access Management *
# Verwendung von Amazon EC2 EC2-Instance-Metadaten als Anmeldeinformationen in der AWS CLI
Wenn Sie die AWS CLI von einer Amazon Elastic Compute Cloud (Amazon EC2) -Instance aus ausführen, können Sie die Bereitstellung von Anmeldeinformationen für Ihre Befehle vereinfachen. Jede Amazon-EC2-Instance enthält Metadaten, die die AWS CLI direkt in Bezug auf temporäre Anmeldeinformationen abfragen kann. Wenn der Instance eine IAM-Rolle zugewiesen wird, ruft sie die Anmeldeinformationen AWS CLI automatisch und sicher aus den Instance-Metadaten ab.
Verwenden Sie die Umgebungsvariable [AWS\$1EC2\$1METADATA\$1DISABLED](cli-configure-envvars.md#envvars-list-AWS_EC2_METADATA_DISABLED), um diesen Dienst zu deaktivieren.
**Topics**
+ [Voraussetzungen](#cli-configure-metadata-prereqs)
+ [Konfigurieren eines Profils für Amazon-EC2-Metadaten](#cli-configure-metadata-configure)
## Voraussetzungen
Um Amazon EC2 EC2-Anmeldeinformationen mit dem zu verwenden AWS CLI, müssen Sie Folgendes ausführen:
+ Installieren und Konfigurieren der AWS CLI. Weitere Informationen erhalten Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md) und [Authentifizierungs- und Zugangsdaten für die AWS CLI](cli-chap-authentication.md).
+ Sie verstehen Konfigurationsdateien und benannte Profile. Weitere Informationen finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
+ Sie haben eine AWS Identity and Access Management (IAM-) Rolle erstellt, die Zugriff auf die benötigten Ressourcen hat, und diese Rolle der Amazon EC2 EC2-Instance zugewiesen, wenn Sie sie starten. *Weitere Informationen finden Sie unter [IAM-Richtlinien für Amazon EC2 im Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) *und Granting* [Applications That Run on Amazon EC2 EC2-Instances Access to AWS Resources](https://docs.aws.amazon.com/IAM/latest/UserGuide/role-usecase-ec2app.html) im IAM-Benutzerhandbuch.*
## Konfigurieren eines Profils für Amazon-EC2-Metadaten
Um anzugeben, dass Sie die im Hosting-Amazon-EC2-Instance-Profil verfügbaren Anmeldeinformationen verwenden möchten, verwenden Sie die folgende Syntax in einem benannten Profil in Ihrer Konfigurationsdatei. Weitere Anweisungen finden Sie in den folgenden Schritten.
```
[profile profilename]
role_arn = arn:aws:iam::123456789012:role/rolename
credential_source = Ec2InstanceMetadata
region = region
```
1. Erstellen Sie ein Profil in Ihrer Konfigurationsdatei.
```
[profile profilename]
```
1. Fügen Sie Ihre IAM-Arn-Rolle hinzu, die Zugriff auf die erforderlichen Ressourcen hat.
```
role_arn = arn:aws:iam::123456789012:role/rolename
```
1. Geben Sie `Ec2InstanceMetadata` als Quelle für die Anmeldeinformationen an.
```
credential_source = Ec2InstanceMetadata
```
1. Legen Sie Ihre Region fest.
```
region = region
```
**Beispiel**
Das folgende Beispiel übernimmt die Rolle *`marketingadminrole`* und verwendet die Region `us-west-2` in einem Instance-Profil von Amazon-EC2 mit dem Namen `marketingadmin`.
```
[profile marketingadmin]
role_arn = arn:aws:iam::123456789012:role/marketingadminrole
credential_source = Ec2InstanceMetadata
region = us-west-2
```
# Beschaffung von Referenzen mit einem externen Prozess in der AWS CLI
**Warnung**
In diesem Thema wird die Beschaffung von Anmeldeinformationen von einem externen Prozess erläutert. Dies könnte ein Sicherheitsrisiko darstellen, wenn der Befehl zum Generieren der Anmeldeinformationen nicht zulässigen Prozessen oder Benutzern zugänglich wird. Wir empfehlen Ihnen, die unterstützten, sicheren Alternativen zu verwenden, die von AWS CLI und bereitgestellt werden, um das Risiko AWS zu verringern, dass Ihre Anmeldeinformationen kompromittiert werden. Sorgen Sie dafür, dass Sie die `config`-Datei und alle zugehörigen Dateien und Tools vor einer Offenlegung sichern.
Stellen Sie sicher, dass Ihr benutzerdefiniertes Anmeldeinformationstool keine geheimen Informationen speichert, `StdErr` da es solche Informationen erfassen und protokollieren AWS CLI kann, wodurch sie möglicherweise unbefugten Benutzern zugänglich gemacht werden. SDKs
Wenn Sie über eine Methode zum Generieren oder Nachschlagen von Anmeldeinformationen verfügen, die nicht direkt von der unterstützt wird AWS CLI, können Sie die AWS CLI so konfigurieren, dass sie verwendet wird, indem Sie die `credential_process` Einstellung in der `config` Datei konfigurieren.
Beispielsweise könnten Sie einen etwa wie folgt aussehenden Eintrag in die `config`-Datei aufnehmen.
```
[profile developer]
credential_process = /opt/bin/awscreds-custom --username helen
```
**Syntax**
Um diese Zeichenfolge auf eine Weise zu erstellen, die mit jedem Betriebssystem kompatibel ist, gehen Sie nach den folgenden Regeln vor:
+ Wenn der Pfad oder Dateiname ein Leerzeichen enthält, umgeben Sie den vollständigen Pfad und Dateinamen mit doppelten Anführungszeichen („ “). Pfad und Dateiname dürfen nur aus folgenden Zeichen bestehen: A-Z a-z 0-9 – \$1. Leerzeichen
+ Wenn ein Parametername oder ein Parameterwert ein Leerzeichen enthält, umgeben Sie dieses Element mit doppelten Anführungszeichen („ “). Umgeben Sie dabei nur den Namen oder den Wert, nicht beides.
+ Fügen Sie keine Umgebungsvariablen in die Zeichenfolgen ein. Sie können beispielsweise nicht `$HOME` oder `%USERPROFILE%` einschließen.
+ Geben Sie den Basisordner nicht als `~` an. Sie müssen den vollständigen Pfad angeben.
**Beispiel für Windows**
```
credential_process = "C:\Path\To\credentials.cmd" parameterWithoutSpaces "parameter with spaces"
```
**Beispiel für Linux oder macOS**
```
credential_process = "/Users/Dave/path/to/credentials.sh" parameterWithoutSpaces "parameter with spaces"
```
**Erwartete Ausgabe des Anmeldeinformationsprogramms**
Der AWS CLI führt den Befehl wie im Profil angegeben aus und liest dann Daten von`STDOUT`. Der von Ihnen angegebene Befehl muss eine JSON-Ausgabe in `STDOUT` generieren, die der folgenden Syntax entspricht.
```
{
"Version": 1,
"AccessKeyId": "an AWS access key",
"SecretAccessKey": "your AWS secret access key",
"SessionToken": "the AWS session token for temporary credentials",
"Expiration": "ISO8601 timestamp when the credentials expire"
}
```
**Anmerkung**
Derzeit muss der `Version`-Schlüssel auf `1` gesetzt sein. Im Laufe der Zeit kann ein höherer Wert erforderlich sein, wenn sich die Struktur weiterentwickelt.
Der `Expiration` Schlüssel ist ein [ISO8601](https://en.wikipedia.org/wiki/ISO_8601)formatierter Zeitstempel. Wenn der `Expiration`-Schlüssel nicht in der Ausgabe des Tools vorhanden ist, geht die CLI davon aus, dass es sich bei den Anmeldeinformationen um langfristige Anmeldeinformationen handelt, die nicht aktualisiert werden. Andernfalls werden die Anmeldeinformationen als temporäre Anmeldeinformationen angesehen und automatisch aktualisiert, indem der Befehl `credential_process` vor ihrem Ablauf erneut ausgeführt wird.
**Anmerkung**
Der speichert AWS CLI ***keine*** externen Prozessanmeldedaten im Cache, so wie er es bei Rollenübernahmen tut. Wenn Caching erforderlich ist, müssen Sie dies im externen Prozess implementieren.
Der externe Prozess kann einen Rückgabecode ungleich Null zurückgeben, um anzuzeigen, dass beim Abrufen der Anmeldeinformationen ein Fehler aufgetreten ist.