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.
# Konfigurieren der Einstellungen für die AWS CLI
In diesem Abschnitt wird erläutert, wie Sie die Einstellungen konfigurieren, mit denen AWS Command Line Interface (AWS CLI) mit AWS interagiert. Diese umfassen u. a. folgende:
+ Die **Anmeldeinformationen** geben an, wer die API aufruft. Anmeldeinformationen werden verwendet, um die Anfrage an die AWS-Server zu verschlüsseln, Ihre Identität zu bestätigen und die zugehörigen Berechtigungsrichtlinien abzurufen. Diese Berechtigungen bestimmen, welche Aktionen Sie ausführen können. Weitere Informationen zum Einrichten Ihrer Anmeldeinformationen finden Sie unter [Authentifizierungs- und Zugangsdaten für die AWS CLI](cli-chap-authentication.md).
+ **Weitere Konfigurationsdetails** zum Anweisen der AWS CLI, wie Anfragen verarbeitet werden, z. B. das Standardausgabeformat und die AWS-Standardregion.
**Anmerkung**
AWS setzt voraus, dass alle eingehenden Anforderungen kryptografisch signiert sind. Die AWS CLI erledigt dies für Sie. Die "Signatur" enthält einen Datums-/Zeitstempel. Aus diesem Grund müssen Sie sicherstellen, dass das Datum und die Uhrzeit des Computers korrekt eingestellt sind. Wenn nicht, weichen Datum/Uhrzeit in der Signatur zu stark von dem Datum und der Uhrzeit ab, die vom AWS-Service erkannt werden, sodass AWS die Anforderung ablehnt.
## Vorrang der Konfiguration und der Anmeldeinformationen
Anmeldeinformationen und Konfigurationseinstellungen befinden sich an mehreren Speicherorten, z. B. System- oder Benutzerumgebungsvariablen, lokale AWS-Konfigurationsdateien, oder werden in der Befehlszeile als Parameter explizit deklariert. Bestimmte Speicherorte haben Vorrang vor anderen. Die AWS CLI-Anmeldeinformationen und Konfigurationseinstellungen 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
+ [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md)
+ [Konfiguration von Umgebungsvariablen für AWS CLI](cli-configure-envvars.md)
+ [Befehlszeilenoptionen in der AWS CLI](cli-configure-options.md)
+ [Konfiguration der Befehlsvervollständigung in AWS CLI](cli-configure-completion.md)
+ [AWS CLI Wiederholungen in der AWS CLI](cli-configure-retries.md)
+ [Verwenden eines HTTP-Proxy für die AWS CLI](cli-configure-proxy.md)
# Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI
Sie können Ihre häufig verwendeten Konfigurationseinstellungen und Anmeldeinformationen in Dateien speichern, die von der AWS CLI verwaltet werden.
Die Dateien sind in `profiles` unterteilt. Standardmäßig AWS CLI verwendet der die Einstellungen des genannten `default` Profils. Wenn Sie alternative Einstellungen verwenden möchten, können Sie zusätzliche Profile erstellen und referenzieren.
Sie können eine einzelne Einstellung überschreiben, indem Sie entweder eine der unterstützten Umgebungsvariablen definieren oder einen Befehlszeilenparameter verwenden. Weitere Informationen zum Vorrang der Konfigurationseinstellungen finden Sie unter [Konfigurieren der Einstellungen für die AWS CLI](cli-chap-configure.md).
**Anmerkung**
Weitere Informationen zum Einrichten Ihrer Anmeldeinformationen finden Sie unter [Authentifizierungs- und Zugangsdaten für die AWS CLI](cli-chap-authentication.md).
**Topics**
+ [Formatieren der Konfigurations- und Anmeldeinformationsdateien](#cli-configure-files-format)
+ [Wo werden Konfigurationseinstellungen gespeichert?](#cli-configure-files-where)
+ [Verwenden von benannten Profilen](#cli-configure-files-using-profiles)
+ [Festlegen und Anzeigen von Konfigurationseinstellungen mithilfe von Befehlen](#cli-configure-files-methods)
+ [Befehlsbeispiele für das Festlegen neuer Konfigurationen und Anmeldeinformationen](#cli-configure-files-examples)
+ [Unterstützte Einstellungen in der `config`-Datei](#cli-configure-files-settings)
## Formatieren der Konfigurations- und Anmeldeinformationsdateien
Die Dateien `config` und `credentials` sind in Abschnitte unterteilt. Die Abschnitte lauten *profiles*, *sso-sessions* und *services*. Ein Abschnitt ist eine benannte Sammlung von Einstellungen und reicht bis zur nächsten Abschnittsdefinitionszeile. Mehrere Profile und Abschnitte können in den `config`- und `credentials`-Dateien gespeichert werden.
Diese Dateien sind Klartextdateien, die folgendes Format verwenden:
+ Abschnittsnamen werden in eckige Klammern [] eingeschlossen, z. B. `[default]`, `[profile user1]` und `[sso-session]`.
+ Alle Einträge in einem Abschnitt haben das allgemeine Format `setting_name=value`.
+ Zeilen können auskommentiert werden, indem die Zeile mit einem Hash-Zeichen (`#`) begonnen wird.
**Die Dateien `config` und `credentials` enthalten die folgenden Abschnittstypen:**
+ [`profile`](#cli-configure-files-format-profile)
+ [`sso-session`](#cli-configure-files-format-sso-session)
+ [`services`](#cli-configure-files-format-services)
### Abschnittstyp: `profile`
Je nach Datei verwenden Profilabschnittsnamen folgendes Format:
+ **Konfigurationsdatei:** `[default]` `[profile user1]`
+ **Anmeldeinformationsdatei:** `[default]` `[user1]`
Verwenden Sie beim Erstellen eines Eintrags in der `credentials`-Datei ***nicht*** das Wort `profile`.
Jedes Profil kann unterschiedliche Anmeldeinformationen und auch verschiedene AWS –Regionen und Ausgabeformate angeben. Fügen Sie beim Benennen des Profils in einer `config`-Datei das Präfixwort "`profile`„ ein. Dieses darf jedoch nicht in der `credentials`-Datei enthalten sein.
Die folgenden Beispiele zeigen eine `credentials`- und eine `config`-Datei mit zwei angegebenen Profilen, Region und Ausgabe. Die erste Datei *[default]* wird verwendet, wenn Sie einen AWS CLI -Befehl ohne Profil ausführen. Die zweite Option wird verwendet, wenn Sie einen AWS CLI Befehl mit dem `--profile user1` Parameter ausführen.
------
#### [ IAM Identity Center (SSO) ]
Dieses Beispiel ist für AWS IAM Identity Center. Weitere Informationen finden Sie unter [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md).
**Anmeldeinformationsdatei**
Die `credentials`-Datei wird nicht für diese Authentifizierungsmethode verwendet.
**Konfigurationsdatei**
```
[default]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = readOnly
region = us-west-2
output = text
[profile user1]
sso_session = my-sso
sso_account_id = 444455556666
sso_role_name = readOnly
region = us-east-1
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
```
------
#### [ IAM Identity Center (Legacy SSO) ]
Dieses Beispiel bezieht sich auf die Legacy-Methode von AWS IAM Identity Center. Weitere Informationen finden Sie unter [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md).
**Anmeldeinformationsdatei**
Die `credentials`-Datei wird nicht für diese Authentifizierungsmethode verwendet.
**Konfigurationsdatei**
```
[default]
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_region = us-east-1
sso_account_id = 111122223333
sso_role_name = readOnly
region = us-west-2
output = text
[profile user1]
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_region = us-east-1
sso_account_id = 444455556666
sso_role_name = readOnly
region = us-east-1
output = json
```
------
#### [ Short-term credentials ]
Dieses Beispiel gilt für die kurzfristigen Anmeldeinformationen von AWS Identity and Access Management. Weitere Informationen finden Sie unter [Authentifizierung mit kurzfristigen Zugangsdaten für den AWS CLI](cli-authentication-short-term.md).
**Anmeldeinformationsdatei**
```
[default]
aws_access_key_id=ASIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
[user1]
aws_access_key_id=ASIAI44QH8DHBEXAMPLE
aws_secret_access_key=je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY
aws_session_token = fcZib3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
**Konfigurationsdatei**
```
[default]
region=us-west-2
output=json
[profile user1]
region=us-east-1
output=text
```
------
#### [ IAM role ]
Dieses Beispiel bezieht sich auf die Übernahme einer IAM-Rolle. Profile, die IAM-Rollen verwenden, rufen Anmeldeinformationen aus einem anderen Profil ab und wenden dann IAM-Rollenberechtigungen an. In den folgenden Beispielen ist `default` das Quellprofil für Anmeldeinformationen und `user1` leiht sich diese Anmeldeinformationen aus und übernimmt anschließend eine neue Rolle. Weitere Informationen finden Sie unter [Verwenden einer IAM-Rolle in der AWS CLI](cli-configure-role.md).
**Anmeldeinformationsdatei**
Die `credentials`-Datei richtet sich danach, welche Authentifizierung Ihr Quellprofil verwendet. Im folgenden Beispiel verwendet das Quellprofil kurzfristige Anmeldeinformationen.
```
[default]
aws_access_key_id=ASIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
**Konfigurationsdatei**
```
[default]
region=us-west-2
output=json
[profile user1]
role_arn=arn:aws:iam::777788889999:role/user1role
source_profile=default
role_session_name=session_user1
region=us-east-1
output=text
```
------
#### [ Amazon EC2 instance metadata credentials ]
Dieses Beispiel bezieht sich auf die Anmeldeinformationen, die aus den Metadaten der Amazon-EC2-Hosting-Instance abgerufen wurden. Weitere Informationen finden Sie unter [Verwendung von Amazon EC2 EC2-Instance-Metadaten als Anmeldeinformationen in der AWS CLI](cli-configure-metadata.md).
**Anmeldeinformationsdatei**
Die `credentials`-Datei wird nicht für diese Authentifizierungsmethode verwendet.
**Konfigurationsdatei**
```
[default]
role_arn=arn:aws:iam::123456789012:role/defaultrole
credential_source=Ec2InstanceMetadata
region=us-west-2
output=json
[profile user1]
role_arn=arn:aws:iam::777788889999:role/user1role
credential_source=Ec2InstanceMetadata
region=us-east-1
output=text
```
------
#### [ Long-term credentials ]
**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).
Dieses Beispiel bezieht sich auf die langfristigen Anmeldeinformationen von AWS Identity and Access Management. Weitere Informationen finden Sie unter [Authentifizierung mit IAM-Benutzeranmeldedaten für AWS CLI](cli-authentication-user.md).
**Anmeldeinformationsdatei**
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
[user1]
aws_access_key_id=AKIAI44QH8DHBEXAMPLE
aws_secret_access_key=je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY
```
**Konfigurationsdatei**
```
[default]
region=us-west-2
output=json
[profile user1]
region=us-east-1
output=text
```
------
Weitere Informationen und zusätzliche Autorisierungs- und Anmeldeinformationsmethoden finden Sie unter [Authentifizierung mit IAM-Benutzeranmeldedaten für AWS CLI](cli-authentication-user.md).
### Abschnittstyp: `sso-session`
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. `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
```
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
```
`sso_account_id` und `sso_role_name` sind jedoch nicht für alle Szenarien der SSO-Token-Konfiguration erforderlich. Wenn Ihre Anwendung nur AWS -Services verwendet, die die Bearer-Authentifizierung 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. Sehen Sie sich die individuelle Anleitung für Ihren AWS Dienst an, um festzustellen, 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
```
Das Authentifizierungs-Token wird auf der Festplatte unter dem Verzeichnis `~/.aws/sso/cache` mit einem Dateinamen zwischengespeichert, der auf dem Sitzungsnamen basiert.
Weitere Informationen zu diesem Konfigurationstyp finden Sie unter [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md).
### Abschnittstyp: `services`
Bei `services` diesem Abschnitt handelt es sich um eine Gruppe von Einstellungen, mit denen benutzerdefinierte Endpunkte für AWS-Service Anfragen konfiguriert werden. Ein Profil wird dann mit einem `services`-Abschnitt verknüpft.
```
[profile dev]
services = my-services
```
Der `services`-Abschnitt ist durch ` = `-Zeilen in Unterabschnitte unterteilt, wobei `` der AWS-Service -ID-Schlüssel ist. Der AWS-Service Bezeichner basiert auf dem API-Modell, indem alle Leerzeichen `serviceId` durch Unterstriche ersetzt und alle Buchstaben klein geschrieben werden. Eine Liste aller Service-ID-Schlüssel, die im `services`-Abschnitt verwendet werden können, finden Sie unter [Verwenden von Endpunkten in der AWS CLI](cli-configure-endpoints.md). Auf den Service-ID-Schlüssel folgen verschachtelte Einstellungen, die jeweils in einer eigenen Zeile stehen, welche durch zwei Leerzeichen eingerückt sind.
Im folgenden Beispiel wird der Endpunkt so konfiguriert, dass er für Anfragen an den Amazon DynamoDB Dienst in dem *my-services* Abschnitt verwendet wird, der im Profil verwendet wird. *dev* Alle unmittelbar folgenden Zeilen, die eingerückt sind, sind in diesem Unterabschnitt enthalten und gelten für diesen Service.
```
[profile dev]
services = my-services
[services my-services]
dynamodb =
endpoint_url = http://localhost:8000
```
Weitere Informationen zu servicespezifischen Endpunkten finden Sie unter [Verwenden von Endpunkten in der AWS CLI](cli-configure-endpoints.md).
Wenn Ihr Profil über rollenbasierte Anmeldeinformationen verfügt, die über einen `source_profile`-Parameter für die IAM-Funktion „Rolle übernehmen“ konfiguriert wurden, verwendet das SDK nur Servicekonfigurationen für das angegebene Profil. Es verwendet keine Profile mit verketteten Rollen. Verwenden Sie beispielsweise die folgende freigegebene `config`-Datei:
```
[profile A]
credential_source = Ec2InstanceMetadata
endpoint_url = https://profile-a-endpoint.aws/
[profile B]
source_profile = A
role_arn = arn:aws:iam::123456789012:role/roleB
services = profileB
[services profileB]
ec2 =
endpoint_url = https://profile-b-ec2-endpoint.aws
```
Wenn Sie das Profil `B` verwenden und in Ihrem Code Amazon EC2 aufrufen, wird der Endpunkt als `https://profile-b-ec2-endpoint.aws` aufgelöst. Wenn Ihr Code eine Anforderung für einen anderen Service stellt, folgt die Endpunktauflösung keiner benutzerdefinierten Logik. Der Endpunkt wird nicht zu dem im Profil `A` definierten globalen Endpunkt aufgelöst. Damit ein globaler Endpunkt für das Profil `B` wirksam wird, müssten Sie `endpoint_url` direkt im Profil `B` festlegen.
## Wo werden Konfigurationseinstellungen gespeichert?
Der AWS CLI speichert vertrauliche Anmeldeinformationen, die Sie mit angeben, `aws configure` in einer lokalen Datei mit dem Namen`credentials`, in einem Ordner mit dem Namen `.aws` in Ihrem Home-Verzeichnis. Die weniger vertraulichen Konfigurationsoptionen, die Sie mit `aws configure` angeben, werden in einer lokalen Datei namens `config` gespeichert, die sich ebenfalls im Ordner `.aws` Ihres Stammverzeichnisses befindet.
**Speichern von Anmeldeinformationen in der Konfigurationsdatei**
Sie können alle Ihre Profileinstellungen in einer einzigen Datei speichern, da sie Anmeldeinformationen aus der `config` Datei lesen AWS CLI können. Wenn in beiden Dateien Anmeldeinformationen für ein Profil mit demselben Namen vorhanden sind, haben die Schlüssel in der Anmeldeinformationsdatei Vorrang. Wir empfehlen, die Anmeldeinformationen in den `credentials`-Dateien zu speichern. Diese Dateien werden auch von den verschiedenen Software-Entwicklungskits für Sprachen verwendet (SDKs). Wenn Sie zusätzlich zu den eine SDKs der Optionen verwenden AWS CLI, überprüfen Sie, ob die Anmeldeinformationen in einer eigenen Datei gespeichert werden sollen.
Der Speicherort Ihres Stammverzeichnis hängt vom Betriebssystem ab. Die folgenden Umgebungsvariablen verweisen auf dieses: `%UserProfile%` in Windows und `$HOME` oder `~` (Tilde) in Unix-basierten Systemen. Sie können auch einen Nicht-Standard-Speicherort für die Dateien angeben, indem Sie die Umgebungsvariablen `AWS_CONFIG_FILE` und `AWS_SHARED_CREDENTIALS_FILE` auf einen anderen lokalen Pfad festlegen. Details dazu finden Sie unter [Konfiguration von Umgebungsvariablen für AWS CLI](cli-configure-envvars.md).
Wenn Sie ein gemeinsam genutztes Profil verwenden, das eine AWS Identity and Access Management (IAM-) Rolle spezifiziert, wird der AWS STS `AssumeRole` Vorgang zum Abrufen temporärer Anmeldeinformationen AWS CLI aufgerufen. Diese Anmeldeinformationen werden dann (in `~/.aws/cli/cache`) gespeichert. Nachfolgende AWS CLI Befehle verwenden die zwischengespeicherten temporären Anmeldeinformationen, bis sie ablaufen, und an diesem Punkt AWS CLI werden die Anmeldeinformationen automatisch aktualisiert.
## Verwenden von benannten Profilen
Wenn kein Profil explizit definiert ist, wird das `default`-Profil verwendet.
Um ein benanntes Profil zu verwenden, fügen Sie dem Befehl die Option `--profile profile-name` hinzu. Das folgende Beispiel listet alle Ihre Amazon-EC2-Instances mit den Anmeldeinformationen und Einstellungen auf, die im Profil `user1` definiert wurden.
```
$ aws ec2 describe-instances --profile user1
```
Wenn ein benanntes Profil für mehrere Befehle verwendet werden soll, müssen Sie das Profil nicht in jedem Befehl angeben. Legen Sie stattdessen die Umgebungsvariable `AWS_PROFILE` als Standardprofil fest. Sie können diese Einstellung mithilfe des `--profile`-Parameters außer Kraft setzen.
------
#### [ Linux or macOS ]
```
$ export AWS_PROFILE=user1
```
------
#### [ Windows ]
```
C:\> setx AWS_PROFILE user1
```
Bei Verwendung von `[set](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/set_1)` zur Festlegung einer Umgebungsvariablen wird der verwendete Wert bis zum Ende der aktuellen Eingabeaufforderungssitzung oder bis zur Festlegung eines anderen Wertes für die Variable geändert.
Wenn Sie [https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx) zum Festlegen einer Umgebungsvariable verwenden, ändert sich der Wert in allen Befehls-Shells, die Sie nach der Ausführung des Befehls erstellen. Befehls-Shells, die zum Zeitpunkt der Befehlsausführung bereits ausgeführt werden, sind ***nicht*** betroffen. Schließen Sie die Befehls-Shell und starten Sie sie neu, um die Auswirkungen der Änderung zu sehen.
Durch die Festlegung der Umgebungsvariablen wird das Standardprofil bis zum Ende der Shell-Sitzung geändert oder bis Sie einen anderen Wert für die Variable bestimmen. Sie können Umgebungsvariablen für zukünftige Sitzungen persistent machen, indem Sie sie in das Startup-Skript Ihrer Shell stellen. Weitere Informationen finden Sie unter [Konfiguration von Umgebungsvariablen für AWS CLI](cli-configure-envvars.md).
------
## Festlegen und Anzeigen von Konfigurationseinstellungen mithilfe von Befehlen
Es gibt mehrere Möglichkeiten, Ihre Konfigurationseinstellungen mithilfe von Befehlen anzuzeigen und festzulegen.
**`[aws configure](https://docs.aws.amazon.com/cli/v1/reference/configure/index.html)`**
Führen Sie diesen Befehl aus, um Ihre -Anmeldeinformationen, Ihre Region und das Ausgabeformat schnell festzulegen und anzuzeigen. Das folgende Beispiel zeigt Beispielwerte.
```
$ 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
```
**`[aws configure set](https://docs.aws.amazon.com/cli/v1/reference/configure/set.html)`**
Sie können alle Anmeldeinformationen oder Konfigurationseinstellungen mit `aws configure set` festlegen. Geben Sie das Profil an, das Sie mit der `--profile`-Einstellung anzeigen oder ändern möchten.
Mit dem folgenden Befehl beispielsweise wird die `region` in dem Profil mit dem Namen `integ` festgelegt.
```
$ aws configure set region us-west-2 --profile integ
```
Um eine Einstellung zu entfernen, löschen Sie die Einstellung in den Dateien `config` und `credentials` manuell in einem Texteditor.
**[https://docs.aws.amazon.com/cli/v1/reference/configure/get.html](https://docs.aws.amazon.com/cli/v1/reference/configure/get.html)**
Sie können alle Anmeldeinformationen oder Konfigurationseinstellungen abrufen, die Sie mit `aws configure get` festgelegt haben. Geben Sie das Profil an, das Sie mit der `--profile`-Einstellung anzeigen oder ändern möchten.
Beispielsweise wird mit dem folgenden Befehl die`region`-Einstellung in dem Profil mit dem Namen `integ` abgerufen.
```
$ aws configure get region --profile integ
us-west-2
```
Wenn die Ausgabe leer ist, ist die Einstellung nicht explizit festgelegt und es wird der Standardwert verwendet.
**[https://docs.aws.amazon.com/cli/latest/reference/reference/configure/import.html](https://docs.aws.amazon.com/cli/latest/reference/reference/configure/import.html)**
Importieren Sie `CSV`-Anmeldeinformationen, die von der IAM-Webkonsole generiert wurden. Dies gilt nicht für Anmeldeinformationen, die von IAM Identity Center generiert wurden. Kunden, die IAM Identity Center verwenden, sollten „aws configure sso“ verwenden. Eine CSV-Datei wird importiert, wobei der Profilname mit dem Benutzernamen übereinstimmt. Die CSV-Datei muss die folgenden Header enthalten.
+ Benutzername
+ Zugriffsschlüssel-ID
+ Geheimer Zugriffsschlüssel
Während der ersten Erstellung des Schlüsselpaares können Sie nach dem Schließen des Dialogfelds **Download .csv file (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 Schlüsselpaarinformationen erstellen. Wenn Sie keinen Zugriff auf Ihre Schlüsselpaar-Informationen haben, müssen Sie ein neues Schlüsselpaar erstellen.
```
$ aws configure import --csv file://credentials.csv
```
**[https://docs.aws.amazon.com/cli/v1/reference/configure/list.html](https://docs.aws.amazon.com/cli/v1/reference/configure/list.html)**
Um Konfigurationsdaten aufzulisten, verwenden Sie den Befehl `aws configure list`. Dieser Befehl listet das Profil, den Zugriffsschlüssel, den geheimen Schlüssel und die Regionskonfigurationsinformationen auf, die für das angegebene Profil verwendet werden. Für jedes Konfigurationselement werden der Wert, der Ort, an dem der Konfigurationswert abgerufen wurde, und der Name der Konfigurationsvariablen angezeigt.
Wenn Sie beispielsweise die AWS-Region in einer Umgebungsvariablen angeben, zeigt Ihnen dieser Befehl den Namen der Region, die Sie konfiguriert haben, dass dieser Wert aus einer Umgebungsvariablen stammt, und den Namen der Umgebungsvariablen.
Bei Methoden mit temporären Anmeldeinformationen wie Rollen und IAM Identity Center zeigt dieser Befehl den temporär zwischengespeicherten Zugriffsschlüssel an, und der geheime Zugriffsschlüssel wird angezeigt.
```
$ aws configure list
NAME : VALUE : TYPE : LOCATION
profile : : None : None
access_key : ****************ABCD : shared-credentials-file :
secret_key : ****************ABCD : shared-credentials-file :
region : us-west-2 : env : AWS_DEFAULT_REGION
```
**[https://docs.aws.amazon.com/cli/v1/reference/configure/list-profiles.html](https://docs.aws.amazon.com/cli/v1/reference/configure/list-profiles.html)**
Um alle Profilnamen aufzulisten, verwenden Sie den Befehl `aws configure list-profiles`.
```
$ aws configure list-profiles
default
test
```
**`aws configure mfa-login`**
Führen Sie diesen Befehl aus, um ein neues Profil für die Multi-Faktor-Authentifizierung (MFA) und Ihre IAM-Benutzeranmeldeinformationen im angegebenen 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.
*Weitere Informationen zur Verwendung von MFA mit IAM finden Sie unter [AWS Multi-Faktor-Authentifizierung in IAM im Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa.html).AWS Identity and Access Management *
**`aws configure sso`**
Führen Sie diesen Befehl aus, um Ihre AWS IAM Identity Center Anmeldeinformationen, Ihre Region und Ihr Ausgabeformat schnell festzulegen und anzuzeigen. Das folgende Beispiel zeigt Beispielwerte.
```
$ 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
```
**`aws configure sso-session`**
Führen Sie diesen Befehl aus, um Ihre AWS IAM Identity Center Anmeldeinformationen, Ihre Region und das Ausgabeformat im `sso-session` Abschnitt der `config` Dateien `credentials` und schnell festzulegen und anzuzeigen. Das folgende Beispiel zeigt Beispielwerte.
```
$ 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
```
**`aws configure export-credentials`**
Führen Sie diesen Befehl aus, um die aktuell festgelegten Anmeldeinformationen im angegebenen Format zu exportieren. Standardmäßig exportiert der Befehl die Standardanmeldedaten in dem `process` Format, einem JSON-Format, das vom Anmeldeinformationsformat AWS SDKs und Tools unterstützt wird.
```
$ aws configure export-credentials
{
"Version": 1,
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
}
```
Verwenden Sie die Optionen `--profile` und `--format`, um ein bestimmtes Profil und Format zu exportieren. Folgende Formatoptionen sind verfügbar:
+ **(Standard) **`process`****‐ Das von der AWS SDKs und `credential_process` Tools-Konfiguration unterstützte JSON-Format.
+ **`env`** – Umgebungsvariablen im exportierten Shell-Format.
+ **`env-no-export`** – Umgebungsvariablen im nicht exportierten Shell-Format.
+ **`powershell`**‐ Umgebungsvariablen im PowerShell Format.
+ **`windows-cmd`** – Umgebungsvariablen im Windows-Befehlszeilenformat.
Im folgenden Beispiel wird das `user1`-Profil in ein exportiertes Shell-Format exportiert.
```
$ aws configure export-credentials --profile user1 --format env
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
## Befehlsbeispiele für das Festlegen neuer Konfigurationen und Anmeldeinformationen
Die folgenden Beispiele zeigen die Konfiguration eines Standardprofils mit Anmeldeinformationen, Region und Ausgabe, die für verschiedene Authentifizierungsmethoden angegeben sind.
------
#### [ Console sessions as short-term credentials ]
In diesem Beispiel können Sie Ihre vorhandenen Konsolenanmeldedaten mit dem `aws login` Befehl verwenden. Diese Anmeldemethode kann mit Root-Anmeldeinformationen verwendet werden, die bei der ersten Kontoeinrichtung erstellt wurden, mit einem IAM-Benutzer oder mit einer föderierten Identität von Ihrem Identitätsanbieter. Weitere Informationen finden Sie unter [Anmeldung für die AWS lokale Entwicklung mit Konsolenanmeldedaten](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html).
```
$ aws login
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]: us-east-1
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://us-east-1.signin.aws.amazon.com/v1/authorize
If you cannot connect to this URL, make sure that you have specified a valid region.
Waiting for login...
Logged in with role `arn:aws:sts::012345678910:user/iam-user`, and configured profile
`default` to use `us-east-1`. This session will expire on October 14, 2025 at 2:04 PST. After this time, you
can renew your session with `aws login`.
```
------
#### [ IAM Identity Center (SSO) ]
Dieses Beispiel bezieht sich auf die AWS IAM Identity Center Verwendung des `aws configure sso` Assistenten. Weitere Informationen finden Sie unter [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md).
```
$ 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
Attempting to automatically open the SSO authorization page in your default browser.
There are 2 AWS accounts available to you.
> DeveloperAccount, developer-account-admin@example.com (111122223333)
ProductionAccount, production-account-admin@example.com (444455556666)
Using the account ID 111122223333
There are 2 roles available to you.
> ReadOnly
FullAccess
Using the role name "ReadOnly"
CLI default client Region [None]: us-west-2
CLI default output format [None]: json
CLI profile name [123456789011_ReadOnly]: user1
```
------
#### [ IAM Identity Center (Legacy SSO) ]
Dieses Beispiel bezieht sich auf die alte Methode zur AWS IAM Identity Center Verwendung des `aws configure sso` Assistenten. Wenn Sie das Legacy-SSO verwenden möchten, lassen Sie den Sitzungsnamen leer. Weitere Informationen finden Sie unter [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md).
```
$ aws configure sso
SSO session name (Recommended):
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]:us-east-1
SSO authorization page has automatically been opened in your default browser.
Follow the instructions in the browser to complete this authorization request.
There are 2 AWS accounts available to you.
> DeveloperAccount, developer-account-admin@example.com (111122223333)
ProductionAccount, production-account-admin@example.com (444455556666)
Using the account ID 111122223333
There are 2 roles available to you.
> ReadOnly
FullAccess
Using the role name "ReadOnly"
CLI default client Region [None]: us-west-2
CLI default output format [None]: json
CLI profile name [123456789011_ReadOnly]: user1
```
------
#### [ Short-term credentials ]
Dieses Beispiel gilt für die kurzfristigen Anmeldeinformationen von AWS Identity and Access Management. Der AWS-Konfigurationsassistent wird verwendet, um die Anfangswerte festzulegen. Anschließend weist der Befehl `aws configure set` den letzten benötigten Wert zu. Weitere Informationen finden Sie unter [Authentifizierung mit kurzfristigen Zugangsdaten für den AWS CLI](cli-authentication-short-term.md).
```
$ 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
$ aws configure set aws_session_token fcZib3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
------
#### [ IAM role ]
Dieses Beispiel bezieht sich auf die Übernahme einer IAM-Rolle. Profile, die IAM-Rollen verwenden, rufen Anmeldeinformationen aus einem anderen Profil ab und wenden dann IAM-Rollenberechtigungen an. In den folgenden Beispielen ist `default` das Quellprofil für Anmeldeinformationen und `user1` leiht sich diese Anmeldeinformationen aus und übernimmt anschließend eine neue Rolle. Für diesen Vorgang gibt es keinen Assistenten. Daher wird jeder Wert mit dem Befehl `aws configure set` festgelegt. Weitere Informationen finden Sie unter [Verwenden einer IAM-Rolle in der AWS CLI](cli-configure-role.md).
```
$ aws configure set role_arn arn:aws:iam::123456789012:role/defaultrole
$ aws configure set source_profile default
$ aws configure set role_session_name session_user1
$ aws configure set region us-west-2
$ aws configure set output json
```
------
#### [ Amazon EC2 instance metadata credentials ]
Dieses Beispiel bezieht sich auf die Anmeldeinformationen, die aus den Metadaten der Amazon-EC2-Hosting-Instance abgerufen wurden. Für diesen Vorgang gibt es keinen Assistenten. Daher wird jeder Wert mit dem Befehl `aws configure set` festgelegt. Weitere Informationen finden Sie unter [Verwendung von Amazon EC2 EC2-Instance-Metadaten als Anmeldeinformationen in der AWS CLI](cli-configure-metadata.md).
```
$ aws configure set role_arn arn:aws:iam::123456789012:role/defaultrole
$ aws configure set credential_source Ec2InstanceMetadata
$ aws configure set region us-west-2
$ aws configure set output json
```
------
#### [ Long-term credentials ]
**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).
Dieses Beispiel bezieht sich auf die langfristigen Anmeldeinformationen von AWS Identity and Access Management. Weitere Informationen finden Sie unter [Authentifizierung mit IAM-Benutzeranmeldedaten für AWS CLI](cli-authentication-user.md).
```
$ 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
```
------
## Unterstützte Einstellungen in der `config`-Datei
**Topics**
+ [Globale Einstellungen](#cli-configure-files-global)
+ [Einstellungen für benutzerdefinierte S3-Befehle](#cli-configure-files-s3)
Die folgenden Einstellungen werden in der `config`-Datei unterstützt. Es werden die Werte in dem angegebenen Profil (oder dem Standardprofil) verwendet, es sei denn, sie werden durch eine gleichnamige Umgebungsvariable oder eine gleichnamige Befehlszeilenoption überschrieben. Weitere Informationen darüber, welche Rangfolgeeinstellungen Vorrang haben, finden Sie unter [Konfigurieren der Einstellungen für die AWS CLI](cli-chap-configure.md)
### Globale Einstellungen
** `account_id_endpoint_mode` **
Gibt an, ob der AWS kontobasierte Endpunkt IDs für Aufrufe von Supported verwendet werden soll. AWS-Services Weitere Informationen zu kontobasierten Endpunkten finden Sie unter [Kontobasierte Endpunkte](cli-configure-endpoints.md#endpoints-accountid).
Diese Einstellung kann auf Folgendes festgelegt werden:
+ **(Standard)** **`preferred`** – Der Endpunkt sollte eine Konto-ID enthalten, falls verfügbar.
+ **`disabled`** – Ein aufgelöster Endpunkt enthält keine Konto-ID.
+ **`required`** – Der Endpunkt muss die Konto-ID enthalten. Wenn die Konto-ID nicht verfügbar ist, gibt das SDK einen Fehler aus.
Kann von der Umgebungsvariablen `AWS\$1ACCOUNT\$1ID\$1ENDPOINT\$1MODE` überschrieben werden. Um kontobasierte Endpunkte zu verwenden, muss die ID in der `AWS\$1ACCOUNT\$1ID`-Umgebungsvariable oder `aws\$1account\$1id`-Einstellung festgelegt werden.
```
account_id_endpoint_mode = preferred
```
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
** `aws_access_key_id` **
Gibt den AWS Zugriffsschlüssel an, der als Teil der Anmeldeinformationen zur Authentifizierung der Befehlsanforderung verwendet wird. Zwar kann dieses in der `config`-Datei gespeichert werden, wir empfehlen Ihnen jedoch, es in der `credentials`-Datei zu speichern.
Kann von der Umgebungsvariablen `AWS_ACCESS_KEY_ID` überschrieben werden. Es ist nicht möglich, die Zugriffsschlüssel-ID als Befehlszeilenoption anzugeben.
```
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
```
** `aws_account_id` **
Gibt die AWS kontobasierte Endpunkt-ID an, die für Anrufe an den Support verwendet werden soll. AWS-Services Weitere Informationen zu kontobasierten Endpunkten finden Sie unter [Kontobasierte Endpunkte](cli-configure-endpoints.md#endpoints-accountid).
Kann von der Umgebungsvariablen `AWS\$1ACCOUNT\$1ID` überschrieben werden. Die `AWS\$1ACCOUNT\$1ID\$1ENDPOINT\$1MODE`-Umgebungsvariable oder `account\$1id\$1endpoint\$1mode`-Einstellung muss auf `preferred` oder `required` gesetzt sein, um diese Einstellung verwenden zu können.
```
aws_account_id = 123456789EXAMPLE
```
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`aws_secret_access_key`**
Gibt den AWS geheimen Schlüssel an, der als Teil der Anmeldeinformationen zur Authentifizierung der Befehlsanforderung verwendet wird. Zwar kann dieses in der `config`-Datei gespeichert werden, wir empfehlen Ihnen jedoch, es in der `credentials`-Datei zu speichern.
Kann von der Umgebungsvariablen `AWS_SECRET_ACCESS_KEY` überschrieben werden. Es ist nicht möglich, den geheimen Zugriffsschlüssel als Befehlszeilenoption anzugeben.
```
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
**`aws_session_token`**
Gibt ein AWS Sitzungstoken an. Ein Sitzungs-Token ist nur erforderlich, wenn Sie manuell temporäre Anmeldeinformationen angeben. Zwar kann dieses in der `config`-Datei gespeichert werden, wir empfehlen Ihnen jedoch, es in der `credentials`-Datei zu speichern.
Kann von der Umgebungsvariablen `AWS_SESSION_TOKEN` überschrieben werden. Es ist nicht möglich, das Sitzungs-Token als Befehlszeilenoption anzugeben.
```
aws_session_token = AQoEXAMPLEH4aoAH0gNCAPyJxz4BlCFFxWNE1OPTgk5TthT+FvwqnKwRcOIfrRh3c/LTo6UDdyJwOOvEVPvLXCrrrUtdnniCEXAMPLE/IvU1dYUg2RVAJBanLiHb4IgRmpRV3zrkuWJOgQs8IZZaIv2BXIa2R4Olgk
```
**`ca_bundle`**
Gibt eine CA-Zertifikat-Bundle (eine Datei mit der Erweiterung `.pem`) an, die zur Überprüfung von SSL-Zertifikaten verwendet wird.
Kann von der Umgebungsvariablen `AWS\$1CA\$1BUNDLE` oder mit der Befehlszeilenoption `--ca-bundle` überschrieben werden.
```
ca_bundle = dev/apps/ca-certs/cabundle-2019mar05.pem
```
**`cli_auto_prompt`**
Aktiviert die automatische Eingabeaufforderung für AWS CLI Version 2. Es gibt zwei Einstellungen, die verwendet werden können:
+ **`on`** verwendet den vollständigen automatischen Prompt-Modus jedes Mal, wenn Sie versuchen, einen `aws`-Befehl auszuführen. Dazu gehört das Drücken der **EINGABETASTE** sowohl nach einem vollständigen Befehl als auch nach einem unvollständigen Befehl.
```
cli_auto_prompt = on
```
+ **`on-partial`** verwendet den partiellen automatischen Prompt-Modus. Wenn ein Befehl unvollständig ist oder aufgrund clientseitiger Validierungsfehler nicht ausgeführt werden kann, wird die automatische Eingabeaufforderung verwendet. Dieser Modus ist besonders nützlich, wenn Sie über bereits vorhandene Skripts oder Runbooks verfügen oder nur für Befehle, mit denen Sie nicht vertraut sind, automatisch aufgefordert werden möchten, anstatt bei jedem Befehl gefragt zu werden.
```
cli_auto_prompt = on-partial
```
Sie können diese `aws\$1cli\$1auto\$1prompt`-Umgebungsvariable mithilfe des `--cli-auto-prompt`- und `--no-cli-auto-prompt`-Befehlszeilenparameters überschreiben.
Informationen zur automatischen Eingabeaufforderungsfunktion von AWS CLI Version 2 finden Sie unter[Aktivieren und Verwenden von Eingabeaufforderungen in AWS CLI](cli-usage-parameters-prompting.md).
**`cli_binary_format`**
Gibt an, wie AWS CLI Version 2 binäre Eingabeparameter interpretiert. Dabei kann es sich um einen der folgenden Werte handeln:
+ **base64** – Dies ist der Standardwert. Ein Eingabeparameter, der als BLOB (Binary Large Object) eingegeben wird, akzeptiert eine base64-kodierte Zeichenfolge. Um echten binären Inhalt zu übergeben, legen Sie den Inhalt in eine Datei und geben den Pfad und den Namen der Datei mit dem Präfix `fileb://` als Wert des Parameters an. Um in einer Datei enthaltenen base64-kodierten Text zu übergeben, geben Sie den Pfad und den Namen der Datei mit dem Präfix `file://` als Wert des Parameters an.
+ **raw-in-base64-out** — Standard für AWS CLI Version 1. Wenn der Wert der Einstellung `raw-in-base64-out` lautet, werden Dateien, auf die mit dem Präfix `file://` verwiesen wird, als Text gelesen und dann versucht die AWS CLI , sie in Binärform zu codieren.
Dieser Eintrag verfügt über keine entsprechende Umgebungsvariable. Sie können den Wert in einem einzelnen Befehl mit dem Parameter `--cli-binary-format raw-in-base64-out` angeben.
```
cli_binary_format = raw-in-base64-out
```
Wenn Sie mithilfe der `fileb://` Präfix-Notation auf einen Binärwert in einer Datei verweisen, erwartet The AWS CLI *immer*, dass die Datei unformatierte Binärinhalte enthält, und versucht nicht, den Wert zu konvertieren.
Wenn Sie mithilfe der `file://` Präfixnotation auf einen Binärwert in einer Datei verweisen, AWS CLI behandelt der die Datei entsprechend der aktuellen `cli_binary_format` Einstellung. Wenn der Wert dieser Einstellung ist `base64` (der Standardwert, wenn er nicht explizit festgelegt ist), AWS CLI erwartet der, dass die Datei Base64-codierten Text enthält. Wenn der Wert dieser Einstellung ist`raw-in-base64-out`, AWS CLI erwartet der, dass die Datei binären Rohinhalt enthält.
**`cli_help_output`**
Ab Version `2.31.0` wird die Anzeige für den Befehl `help` durch die Einstellung `cli_help_output` konfiguriert und hat die folgenden Werte:
+ **(Standard)** `terminal` – Öffnen Sie die Manpage im Terminal.
+ `browser` – Öffnen Sie die Manpage als lokale HTML-Datei in Ihrem Standardbrowser. Ein Hinweis wird auf Ihrem Terminal gedruckt, wenn Ihr Standardbrowser geöffnet wird, und eine Fehlermeldung, wenn der Browser AWS CLI nicht geöffnet werden kann.
+ `url`‐ Drucken Sie die URL zum AWS CLI Online-Referenzhandbuch für die Version aus, die AWS CLI Sie installiert haben. Die Einstellungen für das clientseitige Paging, wie z. B. die `AWS_PAGER` Umgebungsvariable, werden berücksichtigt.
```
cli_help_output = browser
```
Weitere Informationen zum `help`-Befehl finden Sie unter [Zugriff auf Hilfe und Ressourcen für AWS CLI](cli-usage-help.md).
**`cli_history`**
Standardmäßig deaktiviert. Diese Einstellung aktiviert den Befehlsverlauf für die AWS CLI. Nach dem Aktivieren dieser Einstellung AWS CLI zeichnet der den Verlauf der Befehle auf. `aws`
```
cli_history = enabled
```
Sie können Ihren Verlauf mit dem Befehl `aws history list` auflisten und die resultierenden `command_ids` im Befehl `aws history show` verwenden, um Details abzurufen. Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/history/index.html](https://docs.aws.amazon.com/cli/latest/reference/history/index.html) im *AWS CLI -Referenzhandbuch*.
**`cli_pager`**
Gibt das für die Ausgabe verwendete Pager-Programm an. Standardmäßig gibt AWS CLI Version 2 die gesamte Ausgabe über das Standard-Pager-Programm Ihres Betriebssystems zurück.
Kann von der Umgebungsvariablen AWS\$1PAGER überschrieben werden.
```
cli_pager=less
```
**`cli_timestamp_format`**
Gibt das Ausgabeformat von Zeitstempelwerten an. Sie können einen der folgenden Werte angeben:
+ **iso8601** — Der Standardwert für Version 2. AWS CLI [Falls angegeben, AWS CLI werden alle Zeitstempel in der Ausgabe gemäß ISO 8601 neu formatiert.](https://www.iso.org/iso-8601-date-and-time-format.html) Gemäß ISO 8601 formatierte Zeitstempel sehen wie die folgenden Beispiele aus. Das folgende Beispiel zeigt, wie die Uhrzeit formatiert wird, indem Datum und Uhrzeit mit einem `T` und einem `Z` nach der Uhrzeit getrennt werden.
```
YYYY-MM-DDThh:mm:ssZ
```
Das folgende Beispiel zeigt einen Zeitstempel, in dem die vorherige Formatierung verwendet wir.
```
2024-05-08T15:16:43Z
```
+ **wire** — Der Standardwert für Version 1. AWS CLI Falls angegeben, AWS CLI werden alle Zeitstempelwerte genau so angezeigt, wie sie in der HTTP-Abfrageantwort empfangen wurden.
Für diese Einstellung gibt es keine entsprechende Umgebungsvariable oder Befehlszeilenoption. Diese Einstellung ändert Zeitstempeleingaben nicht, sondern nur die Ausgabeformatierung.
```
cli_timestamp_format = iso8601
```
**`credential\$1process`**
Gibt einen externen Befehl an, der AWS CLI ausgeführt wird, um die für diesen Befehl zu verwendenden Authentifizierungsanmeldeinformationen zu generieren oder abzurufen. Der Befehl muss die Anmeldeinformationen in einem bestimmten Format zurückgeben. Weitere Informationen zur Verwendung dieser Einstellung finden Sie unter [Beschaffung von Referenzen mit einem externen Prozess in der AWS CLI](cli-configure-sourcing-external.md).
Zu diesem Eintrag gibt es keine entsprechende Umgebungsvariable oder Befehlszeilenoption.
```
credential_process = /opt/bin/awscreds-retriever --username susan
```
**`credential\$1source`**
Wird innerhalb von Amazon-EC2-Instances oder -Containern verwendet, um anzugeben, wo die AWS CLI Anmeldeinformationen für die Übernahme der Rolle finden kann, die Sie mit dem Parameter `role_arn` angegeben haben. Sie können `source_profile` und `credential_source` nicht im selben Profil angeben.
Dieser Parameter kann einen von drei Werten haben:
+ **Umgebung** — Gibt an, dass Quellanmeldeinformationen aus Umgebungsvariablen abgerufen werden sollen. AWS CLI
+ **Ec2 InstanceMetadata — Gibt an, dass die dem AWS CLI [EC2-Instanzprofil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html)** zugeordnete IAM-Rolle zum Abrufen der Quellanmeldedaten verwendet werden soll.
+ **EcsContainer**— Gibt an, dass die dem AWS CLI ECS-Container zugeordnete IAM-Rolle als Quellanmeldedaten verwendet werden soll.
```
credential_source = Ec2InstanceMetadata
```
**`duration_seconds`**
Gibt die maximale Dauer der Rollensitzung in Sekunden an. Der Wert kann zwischen 900 Sekunden (15 Minuten) und der maximalen Sitzungsdauer für die Rolle liegen maximal 43 200). Dieser Parameter ist optional. Standardmäßig ist der Wert auf 3 600 Sekunden festgelegt.
**`endpoint_url`**
Gibt den Endpunkt an, der für alle Serviceanforderungen verwendet wird. Wenn diese Einstellung im [`services`](#cli-configure-files-format-services)-Abschnitt der `config`-Datei verwendet wird, wird der Endpunkt nur für den angegebenen Service genutzt. Weitere Informationen finden Sie unter [Legen Sie den globalen Endpunkt für alle fest AWS-Services](cli-configure-endpoints.md#endpoints-global).
Im folgenden Beispiel wird der globale Endpunkt `http://localhost:1234` und ein servicespezifischer Endpunkt namens `http://localhost:4567` für Amazon S3 verwendet.
```
[profile dev]
endpoint_url = http://localhost:1234
services = s3-specific
[services s3-specific]
s3 =
endpoint_url = http://localhost:4567
```
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`ignore_configure_endpoint_urls`**
Wenn diese Option aktiviert ist, AWS CLI ignoriert sie alle in der Datei angegebenen benutzerdefinierten Endpunktkonfigurationen. `config` Gültige Werte sind `true` und `false`.
```
ignore_configure_endpoint_urls = true
```
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`external\$1id`**
Gibt eine eindeutige Kennung an, die von Dritten verwendet wird, um eine Rolle in den Konten ihrer Kunden zu übernehmen. Dies entspricht dem Parameter `ExternalId` in der Operation `AssumeRole`. Dieser Parameter ist nur erforderlich, wenn die Vertrauensrichtlinie für die Rolle einen Wert für `ExternalId` angibt. Weitere Informationen finden Sie im *IAM-Benutzerhandbuch* unter [So verwenden Sie eine externe ID, wenn Sie Dritten Zugriff auf Ihre AWS Ressourcen gewähren](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html).
**`max\$1attempts`**
Gibt einen Wert für die maximale Anzahl von Wiederholungsversuchen an, die der AWS CLI Wiederholungshandler verwendet, wobei der erste Aufruf auf den von Ihnen angegebenen `max_attempts` Wert angerechnet wird.
Sie können diesen Wert überschreiben, indem Sie die Umgebungsvariable `AWS_MAX_ATTEMPTS` verwenden.
```
max_attempts = 3
```
**`mfa\$1serial`**
Die ID eines MFA-Geräts, das verwendet werden soll, wenn eine Rolle übernommen wird. Diese ist nur erforderlich, wenn die Vertrauensrichtlinie der übernommenen Rolle eine Bedingung enthält, für die eine MFA-Authentifizierung erforderlich ist. Der Wert kann entweder eine Seriennummer für ein Hardwaregerät (z. B. `GAHT12345678`) oder ein Amazon-Ressourcenname (ARN) für ein virtuelles MFA-Gerät (z. B. `arn:aws:iam::123456789012:mfa/user`) sein.
**`output`**
Gibt das Standardausgabeformat für Befehle an, die mit diesem Profil angefordert wurden. Sie können alle folgenden Werte angeben:
+ **[`json`](cli-usage-output-format.md#json-output)** – Die Ausgabe erfolgt im [JSON](https://json.org/)-Format.
+ **[`yaml`](cli-usage-output-format.md#yaml-output)** –Die Ausgabe erfolgt im [YAML](https://yaml.org/)-Format.
+ **[`yaml-stream`](cli-usage-output-format.md#yaml-stream-output)** – Die Ausgabe erfolgt im [YAML](https://yaml.org/)-Format und wird so auch gestreamt. Streaming ermöglicht eine schnellere Handhabung großer Datentypen.
+ **[`text`](cli-usage-output-format.md#text-output)** – Die Ausgabe wird als mehrere Zeilen mit tabulatorgetrennten Zeichenfolgenwerten formatiert. Dies kann nützlich sein, um die Ausgabe an einen Textprozessor wie `grep`, `sed` oder `awk` zu übergeben.
+ **[`table`](cli-usage-output-format.md#table-output)** – Die Ausgabe erfolgt in Form einer Tabelle mit den Zeichen \$1\$1-, um die Zellenrahmen zu bilden. Normalerweise wird die Information in einem benutzerfreundlichen Format wiedergegeben, das viel einfacher zu lesen ist als die anderen, jedoch programmatisch nicht so nützlich ist.
+ **[`off`](cli-usage-output-format.md#off-output)**— Die Ausgabe unterdrückt alle Befehlsausgaben an stdout. Dies ist nützlich in Automatisierungsskripten und CI/CD Pipelines, bei denen Sie nur den Exit-Code des Befehls überprüfen müssen, ohne die Ausgabe zu verarbeiten.
Kann von der Umgebungsvariablen `AWS_DEFAULT_OUTPUT` oder mit der Befehlszeilenoption `--output` überschrieben werden.
```
output = table
```
**`parameter_validation`**
Gibt an, ob der AWS CLI Client versucht, Parameter zu überprüfen, bevor er sie an den AWS Dienstendpunkt sendet.
+ **true (wahr)** – Dies ist der Standardwert. Falls angegeben, AWS CLI führt der eine lokale Überprüfung der Befehlszeilenparameter durch.
+ **false** — Falls angegeben, AWS CLI validiert der die Befehlszeilenparameter nicht, bevor sie an den AWS Dienstendpunkt gesendet werden.
Zu diesem Eintrag gibt es keine entsprechende Umgebungsvariable oder Befehlszeilenoption.
```
parameter_validation = false
```
**`region`**
Gibt an AWS-Region , an welche Anfragen für Befehle gesendet werden sollen, die mit diesem Profil angefordert wurden.
+ Sie können einen der für den ausgewählten Service verfügbaren Regionscodes angeben, die unter [AWS -Regionen und -Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html) in der *Allgemeine Amazon Web Services-Referenz* aufgeführt sind.
+ `aws_global`ermöglicht es Ihnen, den globalen Endpunkt für Services anzugeben, die zusätzlich zu regionalen Endpunkten wie AWS -Security-Token-Service (AWS STS) und Amazon Simple Storage Service (Amazon S3) einen globalen Endpunkt unterstützen.
Sie können diesen Wert überschreiben, indem Sie die `AWS_REGION`-Umgebungsvariable, die `AWS_DEFAULT_REGION`-Umgebungsvariable oder die Befehlszeilenoption `--region` verwenden.
```
region = us-west-2
```
**`request_checksum_calculation`**
Gibt an, wann eine Prüfsumme für Anforderungsnutzdaten berechnet wird, und bietet die folgenden Optionen:
+ `when_supported` – **(Standard)** Die Prüfsumme der Anforderungsnutzdaten wird berechnet, wenn eine Operation entweder einen Prüfsummenalgorithmus in ihrem Servicemodell angibt oder Anforderungsprüfsummen erfordert.
+ `when_required` – Die Prüfsumme der Anforderungsnutzdaten wird berechnet, wenn eine Operation Anforderungsprüfsummen erfordert oder wenn ein Benutzer einen `requestAlgorithmMember` angibt, der vom AWS-Service modelliert wird.
```
request_checksum_calculation = when_supported
```
Die Umgebungsvariable [`AWS_REQUEST_CHECKSUM_CALCULATION`](cli-configure-envvars.md#envvars-list-AWS_REQUEST_CHECKSUM_CALCULATION) überschreibt diese Einstellung.
**`response_checksum_validation`**
Gibt an, wann eine Prüfsummenvalidierung für Anforderungsnutzdaten durchgeführt wird, und bietet die folgenden Optionen:
+ `when_supported`— **(Standard)** Die Überprüfung der Antwort-Payload-Prüfsumme wird durchgeführt, wenn ein Vorgang in seinem Servicemodell einen Antwortalgorhythmus spezifiziert, den er unterstützt. AWS CLI
+ `when_required`— Die Überprüfung der Antwort-Payload-Prüfsumme wird durchgeführt, wenn eine Operation in ihrem Servicemodell einen Antwortalgorhythmus spezifiziert, den sie AWS CLI unterstützt, und Sie den modellierten in der Operationseingabe `requestValidationModeMember` auf `ENABLED` festlegen.
```
response_checksum_validation = when_supported
```
Die Umgebungsvariable [`AWS_RESPONSE_CHECKSUM_VALIDATION`](cli-configure-envvars.md#envvars-list-AWS_RESPONSE_CHECKSUM_VALIDATION) überschreibt diese Einstellung.
**`retry\$1mode`**
Gibt an, welcher Wiederholungsmodus verwendet wird. AWS CLI Es sind drei Wiederholungsmodi verfügbar: `standard` (Standard), `legacy` (Standard) und `adaptive`. Weitere Informationen zu Wiederholversuchen finden Sie unter [AWS CLI Wiederholungen in der AWS CLI](cli-configure-retries.md).
Sie können diesen Wert überschreiben, indem Sie die Umgebungsvariable `AWS_RETRY_MODE` verwenden.
```
retry_mode = standard
```
**`role\$1arn`**
Gibt den Amazon-Ressourcennamen (ARN) einer IAM-Rolle an, die Sie zur Ausführung der AWS CLI Befehle verwenden möchten. Sie müssen auch einen der folgenden Parameter angeben, um die Anmeldeinformationen zu identifizieren, die berechtigt sind, diese Rolle zu übernehmen:
+ source\$1profile
+ credential\$1source
```
role_arn = arn:aws:iam::123456789012:role/role-name
```
Diese Umgebungsvariable überschreibt die [`AWS_ROLE_ARN`](cli-configure-envvars.md#envvars-list-AWS_ROLE_ARN)-Einstellung.
Weitere Informationen zur Verwendung von Webidentitäten finden Sie unter [Übernehmen einer Rolle mit Web-Identität](cli-configure-role.md#cli-configure-role-oidc).
**`role\$1session\$1name`**
Gibt den Namen an, der der Rollensitzung zugeordnet werden soll. Dieser Wert wird dem Parameter `RoleSessionName` bereitgestellt, wenn die AWS CLI die Operation `AssumeRole` aufruft, und wird Teil des Benutzer-ARN der übernommenen Rolle: ` arn:aws:sts::123456789012:assumed-role/role_name/role_session_name` Dieser Parameter ist optional. Wenn Sie diesen Wert nicht angeben, wird automatisch ein Sitzungsname generiert. Dieser Name wird in den AWS CloudTrail -Protokollen für Einträge angezeigt, die dieser Sitzung zugeordnet sind.
```
role_session_name = maria_garcia_role
```
Die Umgebungsvariable [`AWS_ROLE_SESSION_NAME`](cli-configure-envvars.md#envvars-list-AWS_ROLE_SESSION_NAME) überschreibt diese Einstellung.
Weitere Informationen zur Verwendung von Webidentitäten finden Sie unter [Übernehmen einer Rolle mit Web-Identität](cli-configure-role.md#cli-configure-role-oidc).
**`services`**
Gibt die Servicekonfiguration an, die für Ihr Profil verwendet werden soll.
```
[profile dev-s3-specific-and-global]
endpoint_url = http://localhost:1234
services = s3-specific
[services s3-specific]
s3 =
endpoint_url = http://localhost:4567
```
Weitere Informationen zum Abschnitt `services` finden Sie unter [Abschnittstyp: `services`](#cli-configure-files-format-services).
Die Umgebungsvariable [`AWS_ROLE_SESSION_NAME`](cli-configure-envvars.md#envvars-list-AWS_ROLE_SESSION_NAME) überschreibt diese Einstellung.
Weitere Informationen zur Verwendung von Webidentitäten finden Sie unter [Übernehmen einer Rolle mit Web-Identität](cli-configure-role.md#cli-configure-role-oidc).
**`sdk_ua_app_id`**
Eine einzelne AWS-Konto kann von mehreren Kundenanwendungen verwendet werden, um Anrufe zu AWS-Services tätigen. Die Anwendungs-ID identifiziert, welche Quellanwendung eine Reihe von Aufrufen mithilfe von getätigt hat AWS-Service. AWS SDKs und Dienste verwenden oder interpretieren diesen Wert nur, um ihn in der Kundenkommunikation wieder zum Vorschein zu bringen. Dieser Wert kann beispielsweise in betriebliche E-Mails aufgenommen werden, um eindeutig zu identifizieren, welche Ihrer Anwendungen mit der Benachrichtigung verknüpft ist.
Die Anwendungs-ID ist eine Zeichenfolge mit einer maximalen Länge von 50 Zeichen. Buchstaben, Zahlen und die folgenden Sonderzeichen sind zulässig: `! $ % & * + - . , ^ _ ` | ~`. Standardmäßig wird kein Wert zugewiesen.
```
sdk_ua_app_id = prod1
```
Diese Einstellung kann mit der Umgebungsvariablen [`AWS_SDK_UA_APP_ID`](cli-configure-envvars.md#envvars-list-AWS_SDK_UA_APP_ID) überschrieben werden. Sie können diesen Wert nicht als Befehlszeilenparameter festlegen.
**`sigv4a_signing_region_set`**
Gibt mithilfe einer kommagetrennten Liste die Regionen an, die beim Signieren mit SigV4a verwendet werden sollen. Wenn diese Variable nicht gesetzt ist, AWS CLI verwendet der den Standardwert, der von der verwendet wird AWS-Service. Wenn für kein Standardwert angegeben AWS-Service ist, wird die Anforderungssignatur mit dem Wert von in allen Regionen gültig`*`.
```
sigv4a_signing_region_set = us-west-2, us-east-1
```
Weitere Informationen zu SigV4a finden Sie unter [AWS Signature Version 4 für API-Anforderungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) im *IAM-Benutzerhandbuch*.
Diese Einstellung kann mit der Umgebungsvariablen [`AWS_SIGV4A_SIGNING_REGION_SET`](cli-configure-envvars.md#envvars-list-AWS_SIGV4A_SIGNING_REGION_SET) überschrieben werden. Sie können diesen Wert nicht als Befehlszeilenparameter festlegen.
**`source\$1profile`**
Gibt ein benanntes Profil mit langfristigen Anmeldeinformationen an, die die AWS CLI verwenden kann, um eine Rolle zu übernehmen, die Sie mit dem Parameter `role_arn` angegeben haben. Sie können `source_profile` und `credential_source` nicht im selben Profil angeben.
```
source_profile = production-profile
```
**`sso\$1account\$1id`**
Gibt die AWS Konto-ID an, die die IAM-Rolle mit der Berechtigung enthält, die Sie dem zugehörigen IAM Identity Center-Benutzer gewähren möchten.
Diese Einstellung verfügt nicht über eine Umgebungsvariable oder eine Befehlszeilenoption.
```
sso_account_id = 123456789012
```
**`sso\$1region` **
Gibt die AWS Region an, in der sich der AWS Access Portal-Host befindet. Diese ist getrennt vom `region`-Standard-CLI-Parameter und kann eine andere Region sein.
Diese Einstellung verfügt nicht über eine Umgebungsvariable oder eine Befehlszeilenoption.
```
sso_region = us_west-2
```
**`sso\$1registration\$1scopes` **
Eine durch Kommas getrennte Liste der für die `sso-session` zu autorisierenden Bereiche. Bereiche autorisieren den Zugriff auf über IAM-Identity-Center-Bearer-Token autorisierte Endpunkte. Ein gültiger Bereich ist eine Zeichenfolge, beispielsweise `sso:account:access`. Diese Einstellung gilt nicht für die nicht aktualisierbare Legacy-Konfiguration.
```
sso_registration_scopes = sso:account:access
```
**`sso\$1role\$1name` **
Gibt den Anzeigenamen der IAM-Rolle an, die die Berechtigungen des Benutzers bei der Verwendung dieses Profils definiert.
Diese Einstellung verfügt nicht über eine Umgebungsvariable oder eine Befehlszeilenoption.
```
sso_role_name = ReadAccess
```
**`sso\$1start\$1url`**
Gibt die URL an, die auf das AWS Zugriffsportal der Organisation verweist. Der AWS CLI verwendet diese URL, um eine Sitzung mit dem IAM Identity Center-Dienst einzurichten, um seine Benutzer zu authentifizieren. Verwenden Sie eine der folgenden Methoden, um die URL Ihres AWS Zugriffsportals zu ermitteln:
+ Öffnen Sie Ihre Einladungs-E-Mail. Die URL des AWS Zugriffsportals ist aufgeführt.
+ Öffnen Sie die AWS IAM Identity Center Konsole unter [https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/). Die URL des AWS Zugriffsportals ist in Ihren Einstellungen aufgeführt.
Diese Einstellung verfügt nicht über eine Umgebungsvariable oder eine Befehlszeilenoption.
```
sso_start_url = https://my-sso-portal.awsapps.com/start
```
**`use_dualstack_endpoint`**
Ermöglicht die Verwendung von Dual-Stack-Endpunkten zum Senden AWS von Anfragen. Weitere Informationen zu Dual-Stack-Endpunkten, die IPv4 sowohl IPv6 Datenverkehr als auch unterstützen, finden Sie unter [Verwenden von Amazon S3 S3-Dual-Stack-Endpunkten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/dual-stack-endpoints.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. Dual-Stack-Endpunkte sind für einige Services in einigen Regionen verfügbar. Wenn kein Dual-Stack-Endpunkt für den Service oder AWS-Region existiert, schlägt die Anfrage fehl. Gültige Einstellungen sind `true` und`false`. Diese ist standardmäßig deaktiviert. Weitere Informationen finden Sie unter [Stellen Sie ein, dass Dual-Stack-Endpunkte für alle verwendet werden AWS-Services](cli-configure-endpoints.md#endpoints-dual-stack).
Diese Einstellung und die Einstellung `use_accelerate_endpoint` schließen sich gegenseitig aus.
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`use_fips_endpoint`**
Einige AWS Dienste bieten Endgeräte, die in einigen Fällen den [Federal Information Processing Standard (FIPS) 140-2](https://aws.amazon.com/compliance/fips/) unterstützen. AWS-Regionen Wenn der AWS Dienst FIPS unterstützt, gibt diese Einstellung an, welchen FIPS-Endpunkt verwendet werden soll. AWS CLI Im Gegensatz zu AWS Standardendpunkten verwenden FIPS-Endpunkte eine TLS-Softwarebibliothek, die FIPS 140-2 entspricht. Diese Endpunkte können von Unternehmen erfordert werden, die mit der US-Regierung interagieren. Weitere Informationen finden Sie unter [So eingestellt, dass FIPs Endpunkte für alle verwendet werden AWS-Services](cli-configure-endpoints.md#endpoints-fips).
Wenn diese Einstellung aktiviert ist, aber kein FIPS-Endpunkt für den Dienst in Ihrem vorhanden ist, schlägt der Befehl möglicherweise fehl. AWS-Region AWS Geben Sie in diesem Fall mithilfe der `--endpoint-url`-Option manuell den Endpunkt an, der im Befehl verwendet werden soll, oder verwenden Sie [servicespezifische Endpunkte](cli-configure-endpoints.md#endpoints-service-specific).
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`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 von einem Identitätsanbieter bereitgestellt wird. Die AWS CLI lädt den Inhalt dieser Datei und übergibt ihn als `WebIdentityToken`-Argument an die Operation `AssumeRoleWithWebIdentity`.
Diese Umgebungsvariable überschreibt die `AWS\$1WEB\$1IDENTITY\$1TOKEN\$1FILE`-Einstellung.
Weitere Informationen zur Verwendung von Webidentitäten finden Sie unter [Übernehmen einer Rolle mit Web-Identität](cli-configure-role.md#cli-configure-role-oidc).
**`tcp_keepalive`**
Gibt an, ob der AWS CLI Client TCP-Keep-Alive-Pakete verwendet.
Zu diesem Eintrag gibt es keine entsprechende Umgebungsvariable oder Befehlszeilenoption.
```
tcp_keepalive = false
```
### Einstellungen für benutzerdefinierte S3-Befehle
Amazon S3 unterstützt mehrere Einstellungen, mit denen konfiguriert wird, wie Amazon AWS CLI S3-Operationen ausgeführt werden. Einige gelten für alle S3-Befehle in den `s3`-Namespaces und den `s3api`-Namespaces. Andere sind speziell für die „benutzerdefinierten“ S3-Befehle vorgesehen, die allgemeine Operationen abstrahieren und mehr als nur eine one-to-one Zuordnung zu einer API-Operation ermöglichen. Für die `aws s3`-Übertragungsbefehle `cp`, `sync`, `mv` und `rm` gibt es zusätzliche Einstellungen, die Sie zur Steuerung von S3-Übertragungen verwenden können.
Alle diese Optionen können durch Angabe der verschachtelten Einstellung `s3` in Ihrer `config`-Datei konfiguriert werden. Jede Einstellung wird dann in einer eigenen Zeile eingerückt.
**Anmerkung**
Diese Einstellungen sind völlig optional. Die `aws s3`-Übertragungsbefehle müssten auch ohne Konfiguration dieser Einstellungen erfolgreich ausgeführt werden können. Die Einstellungen werden bereitgestellt, damit Sie die Leistung verbessern oder die besondere Umgebung berücksichtigen können, in der Sie diese `aws s3`-Befehle ausführen.
Diese Einstellungen werden alle unter einem `s3`-Schlüssel der obersten Ebene in der `config`-Datei festgelegt, wie im folgenden Beispiel für das `development`-Profil dargestellt.
```
[profile development]
s3 =
max_concurrent_requests = 20
max_queue_size = 10000
multipart_threshold = 64MB
multipart_chunksize = 16MB
max_bandwidth = 50MB/s
use_accelerate_endpoint = true
addressing_style = path
```
Die folgenden Einstellungen gelten für alle S3-Befehle in den `s3`- oder `s3api`-Namespaces.
**`addressing_style`**
Gibt an, welcher Adressierungsstil verwendet werden soll. Dieser Wert steuert, ob der Bucketname im Hostnamen enthalten oder Teil der URL ist. Gültige Werte sind: `path`, `virtual` und `auto`. Der Standardwert ist `auto`.
Es gibt zwei Möglichkeiten, einen Amazon-S3-Endpunkt zu erstellen. Die erste wird als `virtual` bezeichnet und beinhaltet den Bucket-Namen als Teil des Hostnamens. Beispiel: `https://bucketname.s3.amazonaws.com`. Alternativ können Sie mit dem `path`-Stil den Bucket-Namen wie einen Pfad im URI behandeln. Beispiel: `https://s3.amazonaws.com/bucketname`. Standardmäßig wird in der CLI `auto` verwendet. Dabei wird versucht, möglichst den `virtual`-Stil zu verwenden, gegebenenfalls wird jedoch auf den `path`-Stil zurückgegriffen. Wenn Ihr Bucket-Name beispielsweise nicht DNS-kompatibel ist, kann er nicht Teil des Hostnamens sein und muss im Pfad enthalten sein. Bei Verwendung von `auto` erkennt die CLI diese Bedingung und schaltet automatisch zum `path`-Stil um. Wenn Sie den Adressierungsstil auf festlegen`path`, müssen Sie sicherstellen, dass die AWS Region, in der Sie konfiguriert haben, AWS CLI mit der Region Ihres Buckets übereinstimmt.
**`payload_signing_enabled`**
Gibt an, ob Sigv4-Payloads SHA256 signiert werden sollen. Standardmäßig ist diese Einstellung bei Verwendung von HTTPS für Streaming-Uploads (`UploadPart` und `PutObject`) deaktiviert. Standardmäßig ist die Einstellung für Streaming-Uploads (`UploadPart` und `PutObject`) auf `false` gesetzt, allerdings nur, wenn `ContentMD5` vorhanden ist (wird standardmäßig generiert) und der Endpunkt HTTPS verwendet.
Wenn dieser Wert auf true gesetzt ist, erhalten S3-Anfragen eine zusätzliche Inhaltsvalidierung in Form einer SHA256 Prüfsumme, die für Sie berechnet und in die Anforderungssignatur aufgenommen wird. Wenn „false” festgelegt ist, wird die Prüfsumme nicht berechnet. Eine Deaktivierung dieser Einstellung kann nützlich sein, um den durch die Prüfsummenberechnung entstandenen Leistungsaufwand zu reduzieren.
**`use_accelerate_endpoint`**
Verwendet den Amazon-S3-Accelerate-Endpunkt für alle `s3`- und `s3api`-Befehle. Der Standardwert ist "false". Diese Einstellung und die Einstellung `use_dualstack_endpoint` schließen sich gegenseitig aus.
Wenn auf true gesetzt, AWS CLI leitet der alle Amazon S3 S3-Anfragen an den `S3 Accelerate` Endpunkt unter weiter`s3-accelerate.amazonaws.com`. Um diesen Endpunkt zu verwenden, müssen Sie Ihrem Bucket die Verwendung von `S3 Accelerate` ermöglichen. Alle Anforderungen werden unter Verwendung der virtuellen Bucket-Adressierungsform `my-bucket.s3-accelerate.amazonaws.com` gesendet. `ListBuckets`-, `CreateBucket`- und `DeleteBucket `-Anfragen werden nicht an den S3-Accelerate-Endpunkt gesendet, da dieser Endpunkt diese Operationen nicht unterstützt. Dieses Verhalten kann auch festgelegt werden, wenn der Parameter `--endpoint-url` für einen `s3`- oder `s3api`-Befehl auf `https://s3-accelerate.amazonaws.com` oder `http://s3-accelerate.amazonaws.com` gesetzt ist.
**`use_dualstack_endpoint`**
Ermöglicht die Verwendung von Dual-Stack-Endpunkten zum Senden von `s3`- und `s3api`-Anforderungen. Weitere Informationen zu Dual-Stack-Endpunkten, die IPv4 sowohl IPv6 Datenverkehr als auch unterstützen, finden Sie unter [Verwenden von Amazon S3 S3-Dual-Stack-Endpunkten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/dual-stack-endpoints.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. Dual-Stack-Endpunkte sind für einige Services in einigen Regionen verfügbar. Wenn kein Dual-Stack-Endpunkt für den Service oder AWS-Region existiert, schlägt die Anfrage fehl. Gültige Einstellungen sind `true` und`false`. Diese ist standardmäßig deaktiviert. Weitere Informationen finden Sie unter [Stellen Sie ein, dass Dual-Stack-Endpunkte für alle verwendet werden AWS-Services](cli-configure-endpoints.md#endpoints-dual-stack).
Diese Einstellung und die Einstellung `use_accelerate_endpoint` schließen sich gegenseitig aus.
**`disable_s3_express_session_auth`**
Ob die Amazon S3 Express-Sitzungsauthentifizierung für `s3` `s3api` Befehle deaktiviert werden soll. Der Wert muss ein boolescher Wert sein. Standardwert "false". Wenn dieser Wert auf true gesetzt ist, verwendet der Client NICHT die Amazon S3 Express-Sitzungsauthentifizierung. Wenn auf false gesetzt, wird das Standardverhalten verwendet, um zu bestimmen, ob die Amazon S3 Express-Sitzungsauthentifizierung verwendet werden soll.
Sie können diese Einstellung überschreiben, indem Sie die ` AWS\$1S3\$1DISABLE\$1EXPRESS\$1SESSION\$1AUTH` Umgebungsvariable verwenden.
Die folgenden Einstellungen gelten nur für Befehle im Befehlssatz für den `s3`-Namespace.
**`max_bandwidth`**
Gibt die maximale Bandbreite an, die zum Hoch- und Herunterladen von Daten in und aus Amazon S3 verbraucht werden kann. Standardmäßig ist kein Grenzwert festgelegt.
Diese Einstellung begrenzt die maximale Bandbreite, die S3-Befehle zur Übertragung von Daten an und aus Amazon S3 nutzen können. Der Wert gilt nur für Uploads und Downloads, nicht für Kopien oder Löschvorgänge. Der Wert wird in Bytes pro Sekunde ausgedrückt. Der Wert kann wie folgt angegeben werden:
+ Als ganze Zahl. Bei Angabe von `1048576` wird für die maximale Bandbreitennutzung beispielsweise 1 Megabyte pro Sekunde festgelegt.
+ Als ganze Zahl, gefolgt von einem Suffix für die Rate. Sie können Suffixe unter Verwendung von `KB/s`, `MB/s` oder `GB/s` angeben. Zum Beispiel `300KB/s`, `10MB/s`.
Im Allgemeinen empfehlen wir, zunächst durch Verringerung des Werts für `max_concurrent_requests` eine niedrigere Bandbreitennutzung anzugeben. Wenn der Bandbreitenverbrauch dadurch nicht angemessen auf die gewünschte Rate begrenzt werden kann, können Sie die Einstellung `max_bandwidth` verwenden, um den Bandbreitenverbrauch weiter zu begrenzen. Dies liegt daran, dass `max_concurrent_requests` steuert, wie viele Threads zurzeit ausgeführt werden. Wenn Sie stattdessen zuerst `max_bandwidth` senken, es aber bei einer hohen `max_concurrent_requests`-Einstellung belassen, kann dies dazu führen, dass Threads unnötig warten müssen. Dies kann zu einem übermäßigen Ressourcenverbrauch und Verbindungszeitüberschreitungen führen.
**`max_concurrent_requests`**
Gibt die maximale Anzahl gleichzeitiger Anforderungen an. Der Standardwert lautet 10.
Die `aws s3`-Übertragungsbefehle sind Multithread-Befehle. Zu jedem Zeitpunkt können mehrere Amazon-S3-Anforderungen ausgeführt werden. Wenn Sie beispielsweise den Befehl verwenden, `aws s3 cp localdir s3://bucket/ --recursive` um Dateien in einen S3-Bucket hochzuladen, AWS CLI können sie die Dateien`localdir/file1`,`localdir/file2`, und `localdir/file3` parallel hochladen. Die Einstellung `max_concurrent_requests` gibt die maximale Anzahl von Übertragungsoperationen an, die gleichzeitig ausgeführt werden können.
Unter Umständen müssen Sie diesen Wert aus einem der folgenden Gründe ändern:
+ Verringerung dieses Werts – in einigen Umgebungen kann der Standardwert von 10 gleichzeitigen Anforderungen zu einer Überlastung des Systems führen. Die Folge können Zeitüberschreitungen bei der Verbindung oder eine herabgesetzte Reaktionsfähigkeit des Systems sein. Wenn Sie diesen Wert senken, sind die S3-Übertragungsbefehle weniger ressourcenintensiv. Der Nachteil ist jedoch, dass S3-Übertragungen länger dauern können. Eine Senkung dieses Wertes könnte erforderlich sein, wenn Sie ein Tool zur Begrenzung der Bandbreite verwenden.
+ Erhöhung dieses Werts – in einigen Fällen kann es sinnvoll sein, die Amazon-S3-Übertragungen so schnell wie möglich durchzuführen und dabei so viel Netzwerkbandbreite wie nötig zu beanspruchen. In einem solchen Fall reicht die standardmäßige Anzahl gleichzeitiger Anforderungen möglicherweise nicht aus, um die gesamte verfügbare Netzwerkbandbreite zu nutzen. Eine Erhöhung dieses Werts kann dazu führen, dass sich die Zeit für die Durchführung einer Amazon-S3-Übertragung verkürzt.
**`max_queue_size`**
Gibt die maximale Anzahl von Aufgaben in der Aufgabenwarteschlange an. Der Standardwert lautet 1000.
Das verwendet AWS CLI intern ein Modell, bei dem Amazon S3 S3-Aufgaben in eine Warteschlange gestellt werden, die dann von Verbrauchern ausgeführt werden, deren Anzahl begrenzt ist durch`max_concurrent_requests`. Eine Aufgabe entspricht im Allgemeinen einer einzelnen Amazon-S3-Operation. Eine mögliche Aufgabe könnte beispielsweise `PutObjectTask`, `GetObjectTask` oder `UploadPartTask` sein. Die Aufgaben können der Warteschlange viel schneller hinzugefügt werden, als die Konsumenten die Aufgaben abschließen. Um ein unbegrenztes Wachstum zu vermeiden, ist die Größe der Aufgabenwarteschlange begrenzt. Diese Einstellung ändert den Wert dieser maximalen Anzahl.
Im Allgemeinen müssen Sie diese Einstellung nicht ändern. Diese Einstellung entspricht auch der Anzahl der Aufgaben, von denen sie weiß, dass sie ausgeführt werden müssen. AWS CLI Das bedeutet, dass sie standardmäßig nur 1000 Aufgaben vor sich sehen AWS CLI können. Wenn dieser Wert erhöht wird, AWS CLI können sie schneller die Gesamtzahl der benötigten Aufgaben ermitteln, vorausgesetzt, dass die Warteschlangenrate schneller ist als die Geschwindigkeit, mit der die Aufgaben abgeschlossen werden. Der Nachteil besteht darin, dass für eine größere maximale Warteschlangengröße mehr Speicher benötigt wird.
**`multipart_chunksize`**
Gibt die Blockgröße an, die für mehrteilige Übertragungen einzelner Dateien AWS CLI verwendet wird. Der Standardwert ist 8 MB und mindestens 5 MB.
Wenn eine Datei den `multipart_threshold`-Wert überschreitet, teilt die AWS CLI die Datei in Blöcke dieser Größe. Dieser Wert kann mit derselben Syntax wie `multipart_threshold` angegeben werden, also entweder als ganzzahlige Bytezahl oder unter Verwendung einer Größe und eines Suffixes.
**`multipart_threshold`**
Gibt den Größenschwellenwert an, der für mehrteilige Übertragungen einzelner Dateien AWS CLI verwendet wird. Der Standardwert ist 8 MB.
Beim Hochladen, Herunterladen oder Kopieren einer Datei gehen die Amazon-S3-Befehle zu mehrteiligen Operationen über, wenn die Datei diese Größe überschreitet. Sie können diesen Wert auf zwei Arten angeben:
+ Dateigröße in Bytes. Beispiel, `1048576`.
+ Dateigröße mit einem Größensuffix. Sie können `KB`, `MB`, `GB` oder `TB` verwenden. Zum Beispiel: `10MB`, `1GB`
**Anmerkung**
S3 kann Beschränkungen für gültige Werte anwenden, die für mehrteilige Operationen verwendet werden können. Weitere Informationen finden Sie in der [S3-Dokumentation zu mehrteiligen Uploads](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) im *Benutzerhandbuch zu Amazon Simple Storage Service*.
# Konfiguration von Umgebungsvariablen für AWS CLI
Umgebungsvariablen sind eine weitere Möglichkeit, Konfigurationsoptionen und Anmeldeinformationen anzugeben. Sie sind nützlich, wenn Sie Skripte erstellen möchten.
**Vorrang von Optionen**
+ Wenn Sie eine Option mit einer der in diesem Thema beschriebenen Umgebungsvariablen angeben, setzt sie jeden Wert außer Kraft, der aus einem Profil in der Konfigurationsdatei geladen wurde.
+ Wenn Sie eine Option mithilfe eines Parameters in der AWS CLI Befehlszeile angeben, überschreibt sie jeden Wert aus der entsprechenden Umgebungsvariablen oder einem Profil in der Konfigurationsdatei.
Weitere Hinweise zur Rangfolge und dazu, wie AWS CLI festgelegt wird, welche Anmeldeinformationen verwendet werden sollen, finden Sie unter. [Konfigurieren der Einstellungen für die AWS CLI](cli-chap-configure.md)
**Topics**
+ [Festlegen von Umgebungsvariablen](#envvars-set)
+ [AWS CLI unterstützte Umgebungsvariablen](#envvars-list)
## Festlegen von Umgebungsvariablen
Die folgenden Beispiele zeigen, wie Sie Umgebungsvariablen für den Standardbenutzer konfigurieren können.
------
#### [ Linux or macOS ]
```
$ export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
$ export AWS_DEFAULT_REGION=us-west-2
```
Durch die Festlegung der Umgebungsvariablen wird der verwendete Wert bis zum Ende der Shell-Sitzung oder bis zur Festlegung eines anderen Wertes für die Variable geändert. Sie können Variablen für zukünftige Sitzungen persistent machen, indem Sie sie im Startup-Skript Ihrer Shell festlegen.
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx AWS_ACCESS_KEY_ID AKIAIOSFODNN7EXAMPLE
C:\> setx AWS_SECRET_ACCESS_KEY wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
C:\> setx AWS_DEFAULT_REGION us-west-2
```
Bei Verwendung von [https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx) zur Festlegung einer Umgebungsvariablen wird der verwendete Wert in der aktuellen Eingabeaufforderungssitzung und allen nach Ausführung des Befehls erstellten Eingabeaufforderungssitzungen geändert. Andere Befehls-Shells, die zum Zeitpunkt der Befehlsausführung bereits ausgeführt werden, sind hiervon ***nicht*** betroffen. Möglicherweise müssen Sie Ihr Terminal neu starten, damit die Einstellungen geladen werden.
**Einrichten nur für die aktuelle Sitzung**
Bei Verwendung von `[set](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/set_1)` zur Festlegung einer Umgebungsvariablen wird der verwendete Wert bis zum Ende der aktuellen Eingabeaufforderungssitzung oder bis zur Festlegung eines anderen Wertes für die Variable geändert.
```
C:\> set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
C:\> set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
C:\> set AWS_DEFAULT_REGION=us-west-2
```
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
PS C:\> $Env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
PS C:\> $Env:AWS_DEFAULT_REGION="us-west-2"
```
Wenn Sie an der PowerShell Eingabeaufforderung eine Umgebungsvariable festlegen, wie in den vorherigen Beispielen gezeigt, wird der Wert nur für die Dauer der aktuellen Sitzung gespeichert. Um die Einstellung der Umgebungsvariablen für alle Sitzungen PowerShell und Befehlszeilensitzungen beizubehalten, speichern Sie sie mithilfe der **Systemanwendung** in der **Systemsteuerung**. Alternativ können Sie die Variable für alle future PowerShell Sitzungen festlegen, indem Sie sie zu Ihrem PowerShell Profil hinzufügen. Weitere Informationen zum Speichern von Umgebungsvariablen oder deren Beibehaltung über mehrere Sitzungen hinweg finden Sie in der [PowerShell Dokumentation](https://learn.microsoft.com/powershell/module/microsoft.powershell.core/about/about_environment_variables).
------
## AWS CLI unterstützte Umgebungsvariablen
Das AWS CLI unterstützt die folgenden Umgebungsvariablen.
**`AWS_ACCESS_KEY_ID`**
Gibt einen AWS Zugriffsschlüssel an, der einem IAM-Konto zugeordnet ist.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `aws_access_key_id`. Es ist nicht möglich, die Zugriffsschlüssel-ID mithilfe einer Befehlszeilenoption anzugeben.
**`AWS_ACCOUNT_ID`**
Gibt die AWS kontobasierte Endpunkt-ID an, die für Anrufe an den Support verwendet werden soll. AWS-Services Weitere Informationen zu kontobasierten Endpunkten finden Sie unter [Kontobasierte Endpunkte](cli-configure-endpoints.md#endpoints-accountid).
Diese Einstellung überschreibt die `aws\$1account\$1id`-Einstellung. Die `AWS\$1ACCOUNT\$1ID\$1ENDPOINT\$1MODE`-Umgebungsvariable oder `account\$1id\$1endpoint\$1mode`-Einstellung muss auf `preferred` oder `required` gesetzt sein, um diese Einstellung verwenden zu können.
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`AWS_ACCOUNT_ID_ENDPOINT_MODE`**
Gibt an, ob der AWS kontobasierte Endpunkt IDs für Anrufe an den Support verwendet werden soll. AWS-Services Weitere Informationen zu kontobasierten Endpunkten finden Sie unter [Kontobasierte Endpunkte](cli-configure-endpoints.md#endpoints-accountid).
Diese Einstellung kann auf Folgendes festgelegt werden:
+ **(Standard)** **`preferred`** – Der Endpunkt sollte eine Konto-ID enthalten, falls verfügbar.
+ **`disabled`** – Ein aufgelöster Endpunkt enthält keine Konto-ID.
+ **`required`** – Der Endpunkt muss die Konto-ID enthalten. Wenn die Konto-ID nicht verfügbar ist, gibt das SDK einen Fehler aus.
Diese Einstellung überschreibt die `account\$1id\$1endpoint\$1mode`-Einstellung. Um kontobasierte Endpunkte zu verwenden, muss die ID in der `AWS\$1ACCOUNT\$1ID`-Umgebungsvariable oder `aws\$1account\$1id`-Einstellung festgelegt werden.
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`AWS_CA_BUNDLE`**
Gibt den Pfad zu einem Zertifikat-Bundle für die HTTPS-Zertifikatvalidierung an.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `ca\$1bundle`. Sie können diese Umgebungsvariable mithilfe des `--ca-bundle`-Befehlszeilenparameters überschreiben.
**`AWS_CLI_AUTO_PROMPT`**
Aktiviert die automatische Aufforderung für AWS CLI Version 2. Es gibt zwei Einstellungen, die verwendet werden können:
+ **`on`** verwendet den vollständigen automatischen Prompt-Modus jedes Mal, wenn Sie versuchen, einen `aws`-Befehl auszuführen. Dazu gehört das Drücken der **EINGABETASTE** sowohl nach einem vollständigen Befehl als auch nach einem unvollständigen Befehl.
+ **`on-partial`** verwendet den partiellen automatischen Prompt-Modus. Wenn ein Befehl unvollständig ist oder aufgrund clientseitiger Validierungsfehler nicht ausgeführt werden kann, wird die automatische Eingabeaufforderung verwendet. Dieser Modus ist nützlich, wenn Sie über bereits vorhandene Skripte oder Runbooks verfügen oder nur für Befehle, mit denen Sie nicht vertraut sind, automatisch aufgefordert werden möchten, anstatt bei jedem Befehl gefragt zu werden.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `cli\$1auto\$1prompt`. Sie können diese Umgebungsvariable mithilfe des `--cli-auto-prompt`- und `--no-cli-auto-prompt`-Befehlszeilenparameters überschreiben.
Informationen zur automatischen Eingabeaufforderungsfunktion von AWS CLI Version 2 finden Sie unter[Aktivieren und Verwenden von Eingabeaufforderungen in AWS CLI](cli-usage-parameters-prompting.md).
**`AWS_CLI_FILE_ENCODING`**
Gibt die für Textdateien verwendete Kodierung an. Standardmäßig entspricht die Kodierung Ihrem Gebietsschema. Verwenden Sie die Umgebungsvariable `aws_cli_file_encoding`, um die Kodierung so festzulegen, dass sie sich vom Gebietsschema unterscheidet. Wenn Sie beispielsweise Windows mit der Standardcodierung `CP1252` verwenden, legt `aws_cli_file_encoding=UTF-8` die CLI so fest, dass Textdateien mit `UTF-8` geöffnet werden.
**`AWS_CLI_HISTORY_FILE`**
Setzt den Standardspeicherort für das Speichern des Befehlsverlaufs außer Kraft, wenn die `cli_history` Funktion aktiviert ist. Der Standardpfad ist `~/.aws/cli/history/history.db`. Sie können diese Variable verwenden, um einen alternativen Speicherort anzugeben.
**`AWS_CLI_S3_MV_VALIDATE_SAME_S3_PATHS`**
Wenn die Quell- und Ziel-Buckets bei Verwendung des `s3 mv`-Befehls identisch sind, kann die Quelldatei oder das Quellobjekt auf sich selbst verschoben werden, was zu einem versehentlichen Löschen Ihrer Quelldatei oder Ihres Quellobjekts führen kann. Die `AWS_CLI_S3_MV_VALIDATE_SAME_S3_PATHS` Umgebungsvariable und `--validate-same-s3-paths` -option geben an, ob Ihr Access Point ARNs oder Ihre Access Point-Aliase in Ihrer Amazon S3-Quelle oder Ihrem Amazon S3-Ziel URIs validiert werden sollen.
Die Pfadvalidierung für `s3 mv` erfordert zusätzliche API-Aufrufe.
**`AWS_S3_DISABLE_EXPRESS_SESSION_AUTH`**
Ob die S3 Express-Sitzungsauthentifizierung deaktiviert werden soll. Der Wert muss ein boolescher Wert sein. Standardwert "false". Wenn der Wert auf true gesetzt ist, verwendet der Client NICHT die S3 Express-Sitzungsauthentifizierung.
Falls definiert, überschreibt diese Umgebungsvariable den Wert für die S3-Profileinstellung`disable_s3_express_session_auth`.
**`AWS_CONFIG_FILE`**
Gibt den Speicherort der Datei an, die zum Speichern von Konfigurationsprofilen AWS CLI verwendet wird. Der Standardpfad ist `~/.aws/config`.
Sie können diesen Wert nicht in einer benannten Profileinstellung oder mithilfe eines Befehlszeilenparameters angeben.
**`AWS_DATA_PATH`**
Eine Liste zusätzlicher Verzeichnisse, die `~/.aws/models` beim Laden von AWS CLI Daten außerhalb des integrierten Suchpfads überprüft werden sollen. Durch die Festlegung dieser Umgebungsvariable werden zusätzliche Verzeichnisse angegeben, die zuerst überprüft werden, bevor auf die integrierten Suchpfade zurückgegriffen wird. Mehrere Einträge sollten mit dem `os.pathsep`-Zeichen getrennt werden (unter Linux oder macOS `:` und unter Windows `;`).
**`AWS_DEFAULT_OUTPUT`**
Gibt das zu verwendende [Ausgabeformat](cli-usage-output.md) an.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `output`. Sie können diese Umgebungsvariable mithilfe des `--output`-Befehlszeilenparameters überschreiben.
**`AWS_DEFAULT_REGION`**
Der `Default region name` identifiziert die AWS Region, an deren Server Sie Ihre Anfragen standardmäßig senden möchten. Dies ist in der Regel die nächstgelegene Region, aber jede Region ist zulässig. Sie können beispielsweise `us-west-2` eingeben, um USA West (Oregon) zu verwenden. Dies ist die Region, an die alle späteren Anfragen gesendet werden, es sei denn, Sie geben in einem Befehl etwas anderes an.
Sie müssen eine AWS Region angeben, wenn Sie die verwenden AWS CLI, entweder explizit oder indem Sie eine Standardregion festlegen. Eine Liste der verfügbaren Regionen finden Sie unter [Regionen und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html). Die von der verwendeten Regionsbezeichner AWS CLI sind dieselben Namen, die Sie in den Dienstendpunkten AWS-Managementkonsole URLs sehen.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `region`. Sie können diese Umgebungsvariable überschreiben, indem Sie den `--region` Befehlszeilenparameter und die AWS SDK-kompatible `AWS_REGION` Umgebungsvariable verwenden.
**`AWS_EC2_METADATA_DISABLED`**
Deaktiviert die Verwendung des Amazon-EC2-Instance-Metadaten-Services (IMDS).
Wenn auf „true“ gesetzt, werden Benutzeranmeldeinformationen oder -konfigurationen (wie die Region) nicht vom IMDS angefordert.
**`AWS_ENDPOINT_URL`**
Gibt den Endpunkt an, der für alle Serviceanforderungen verwendet wird. Weitere Informationen finden Sie unter [Legen Sie den globalen Endpunkt für alle fest AWS-Services](cli-configure-endpoints.md#endpoints-global).
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`AWS_ENDPOINT_URL_`**
Gibt einen benutzerdefinierten Endpunkt an, der für einen bestimmten Dienst verwendet wird und der durch den AWS-Service Bezeichner ersetzt `` wird. Amazon DynamoDB Hat zum Beispiel ein `serviceId` von [https://github.com/boto/botocore/blob/bcaf618c4b93c067efa0b85d3e92f3985ff60906/botocore/data/dynamodb/2012-08-10/service-2.json#L10](https://github.com/boto/botocore/blob/bcaf618c4b93c067efa0b85d3e92f3985ff60906/botocore/data/dynamodb/2012-08-10/service-2.json#L10). Für diesen Service lautet die Umgebungsvariable für die Endpunkt-URL `AWS_ENDPOINT_URL_DYNAMODB`.
Eine Liste aller servicespezifischen Umgebungsvariablen finden Sie unter [Liste der servicespezifischen Kennungen](cli-configure-endpoints.md#endpoints-service-specific-table).
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration befinden sich an mehreren Stellen, z. B. in den System- oder Benutzerumgebungsvariablen, in lokalen AWS Konfigurationsdateien, oder sie werden explizit in der Befehlszeile als Parameter deklariert. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`AWS_IGNORE_CONFIGURED_ENDPOINT_URLS`**
Wenn diese Option aktiviert ist, AWS CLI ignoriert sie alle benutzerdefinierten Endpunktkonfigurationen. Gültige Werte sind `true` und `false`. Weitere Informationen finden Sie unter [Legen Sie den globalen Endpunkt für alle fest AWS-Services](cli-configure-endpoints.md#endpoints-global).
Die Einstellungen für die Endpunktkonfiguration 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. Informationen zur Priorität von Endpunkten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration befinden sich an mehreren Stellen, z. B. in den System- oder Benutzerumgebungsvariablen, in lokalen AWS Konfigurationsdateien, oder werden in der Befehlszeile explizit als Parameter deklariert. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**[`AWS_MAX_ATTEMPTS`](cli-configure-files.md#cli-config-max_attempts)**
Gibt einen Wert für die maximale Anzahl von Wiederholungsversuchen an, die der AWS CLI Wiederholungshandler verwendet, wobei der erste Aufruf auf den von Ihnen angegebenen Wert angerechnet wird. Weitere Informationen zu Wiederholversuchen finden Sie unter [AWS CLI Wiederholungen in der AWS CLI](cli-configure-retries.md).
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `max_attempts`.
**`AWS_METADATA_SERVICE_NUM_ATTEMPTS`**
Beim Versuch, Anmeldeinformationen für eine Amazon EC2 EC2-Instance abzurufen, die mit einer IAM-Rolle konfiguriert wurde, wird AWS CLI versucht, Anmeldeinformationen einmal vom Instance-Metadaten-Service abzurufen, bevor der Vorgang beendet wird. Wenn Sie wissen, dass Ihr Code auf einer Amazon-EC2-Instance ausgeführt wird, können Sie diesen Wert erhöhen, damit die AWS CLI mehrere Versuche unternimmt, bevor sie aufgibt.
**`AWS_METADATA_SERVICE_TIMEOUT`**
Die Anzahl der Sekunden, bevor bei einer Verbindung zum Instance-Metadaten-Service eine Zeitüberschreitung eintritt. Wenn Sie versuchen, Anmeldeinformationen auf einer Amazon-EC2-Instance abzurufen, die mit einer IAM-Rolle konfiguriert wurden, tritt für eine Verbindung zum Instance-Metadaten-Service eine Zeitüberschreitung nach standardmäßig einer Sekunde ein. Wenn Sie wissen, dass Sie eine Amazon-EC2-Instance mit einer konfigurierten IAM-Rolle ausführen, können Sie diesen Wert bei Bedarf erhöhen.
**[`AWS_PAGER`](cli-configure-files.md#cli-config-cli_pager)**
Gibt das für die Ausgabe verwendete Pager-Programm an. Standardmäßig gibt AWS CLI Version 2 die gesamte Ausgabe über das Standard-Pager-Programm Ihres Betriebssystems zurück.
Um die gesamte Verwendung eines externen Auslagerungsprogramms zu deaktivieren, setzen Sie die Variable auf eine leere Zeichenfolge.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `cli_pager`.
**[`AWS_PROFILE`](cli-configure-files.md#cli-configure-files-using-profiles)**
Gibt den Namen des AWS CLI Profils mit den zu verwendenden Anmeldeinformationen und Optionen an. Dabei kann es sich um den Namen eines Profils handeln, das in einer `credentials`- oder `config`-Datei gespeichert ist, oder um den Wert `default` zur Nutzung des Standardprofils.
Ist sie definiert, überschreibt diese Umgebungsvariable das Verhalten, bei dem das Profil mit dem Namen `[default]` in der Konfigurationsdatei verwendet wird. Sie können diese Umgebungsvariable mithilfe des `--profile`-Befehlszeilenparameters überschreiben.
**`AWS_REGION`**
Die AWS SDK-kompatible Umgebungsvariable, die die AWS Region angibt, an die die Anfrage gesendet werden soll.
Falls definiert, überschreibt diese Option den Wert für die Umgebungsvariable `AWS_DEFAULT_REGION` und die Profileinstellung `region`. Sie können diese Umgebungsvariable mithilfe des `--region`-Befehlszeilenparameters überschreiben.
**`AWS_REQUEST_CHECKSUM_CALCULATION`**
Gibt an, wann eine Prüfsumme für Anforderungsnutzdaten berechnet wird, und bietet die folgenden Optionen:
+ `when_supported` – **(Standard)** Die Prüfsumme der Anforderungsnutzdaten wird berechnet, wenn eine Operation entweder einen Prüfsummenalgorithmus in ihrem Servicemodell angibt oder Anforderungsprüfsummen erfordert.
+ `when_required` – Die Prüfsumme der Anforderungsnutzdaten wird berechnet, wenn eine Operation Anforderungsprüfsummen erfordert oder wenn ein Benutzer einen `requestAlgorithmMember` angibt, der vom AWS-Service modelliert wird.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung [`request_checksum_calculation`](cli-configure-files.md#cli-config-request_checksum_calculation).
**`AWS_RESPONSE_CHECKSUM_VALIDATION`**
Gibt an, wann eine Prüfsummenvalidierung für Anforderungsnutzdaten durchgeführt wird, und bietet die folgenden Optionen:
+ `when_supported`— **(Standard)** Die Überprüfung der Antwort-Payload-Prüfsumme wird durchgeführt, wenn eine Operation in ihrem Servicemodell einen Antwortalgorhythmus spezifiziert, den AWS CLI sie unterstützt.
+ `when_required`— Die Überprüfung der Antwort-Payload-Prüfsumme wird durchgeführt, wenn eine Operation in ihrem Servicemodell einen Antwortalgorhythmus spezifiziert, den sie AWS CLI unterstützt, und Sie den modellierten in der Operationseingabe `requestValidationModeMember` auf `ENABLED` festlegen.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung [`response_checksum_validation`](cli-configure-files.md#cli-config-response_checksum_validation).
**[`AWS_RETRY_MODE`](cli-configure-files.md#cli-config-retry_mode)**
Gibt an, welcher Wiederholungsmodus verwendet wird. AWS CLI Es stehen drei Wiederholungsmodi zur Verfügung: Legacy (Standard), Standard und Adaptiv. Weitere Informationen zu Wiederholversuchen finden Sie unter [AWS CLI Wiederholungen in der AWS CLI](cli-configure-retries.md).
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `retry_mode`.
**`AWS_ROLE_ARN`**
Gibt den Amazon-Ressourcennamen (ARN) einer IAM-Rolle mit einem Web-Identitätsanbieter an, den Sie zur Ausführung der AWS CLI Befehle verwenden möchten.
Wird mit `AWS_WEB_IDENTITY_TOKEN_FILE`- und `AWS_ROLE_SESSION_NAME`-Umgebungsvariablen genutzt.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung [`role_arn`](cli-configure-files.md#cli-config-role_arn). Sie können keinen Rollensitzungsnamen als Befehlszeilenparameter angeben.
Diese Umgebungsvariable gilt nur für eine Übernahmerolle mit dem Web-Identitätsanbieter, sie gilt nicht für die allgemeine Konfiguration des Rollenanbieters.
Weitere Informationen zur Verwendung von Webidentitäten finden Sie unter [Übernehmen einer Rolle mit Web-Identität](cli-configure-role.md#cli-configure-role-oidc).
**`AWS_ROLE_SESSION_NAME`**
Gibt den Namen an, der der Rollensitzung zugeordnet werden soll. Dieser Wert wird dem `RoleSessionName` Parameter beim AWS CLI Aufrufen der `AssumeRole` Operation zur Verfügung gestellt und wird Teil des angenommenen Rollenbenutzers ARN:` arn:aws:sts::123456789012:assumed-role/role_name/role_session_name`. Dieser Parameter ist optional. Wenn Sie diesen Wert nicht angeben, wird automatisch ein Sitzungsname generiert. Dieser Name erscheint in den AWS CloudTrail Protokollen für Einträge, die mit dieser Sitzung verknüpft sind.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung [`role_session_name`](cli-configure-files.md#cli-config-role_session_name).
Wird mit `AWS_ROLE_ARN`- und `AWS_WEB_IDENTITY_TOKEN_FILE`-Umgebungsvariablen genutzt.
Weitere Informationen zur Verwendung von Webidentitäten finden Sie unter [Übernehmen einer Rolle mit Web-Identität](cli-configure-role.md#cli-configure-role-oidc).
Diese Umgebungsvariable gilt nur für eine Übernahmerolle mit dem Web-Identitätsanbieter, sie gilt nicht für die allgemeine Konfiguration des Rollenanbieters.
**`AWS_SDK_UA_APP_ID`**
Eine einzelne AWS-Konto kann von mehreren Kundenanwendungen verwendet werden, um Anrufe zu tätigen AWS-Services. Die Anwendungs-ID identifiziert, welche Quellanwendung eine Reihe von Aufrufen mithilfe von getätigt hat AWS-Service. AWS SDKs und Dienste verwenden oder interpretieren diesen Wert nur, um ihn in der Kundenkommunikation wieder zum Vorschein zu bringen. Dieser Wert kann beispielsweise in betriebliche E-Mails aufgenommen werden, um eindeutig zu identifizieren, welche Ihrer Anwendungen mit der Benachrichtigung verknüpft ist.
Standardmäßig ist kein Wert vorhanden.
Die Anwendungs-ID ist eine Zeichenfolge mit einer maximalen Länge von 50 Zeichen. Dabei sind Buchstaben, Zahlen und die folgenden Sonderzeichen zulässig:
```
! $ % & * + - . , ^ _ ` | ~
```
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung [`sdk_ua_app_id`](cli-configure-files.md#cli-config-sdk_ua_app_id). Es ist nicht möglich, die Anwendungs-ID als Befehlszeilenoption anzugeben.
**`AWS_SECRET_ACCESS_KEY`**
Gibt den geheimen Schlüssel an, der mit dem Zugriffsschlüssel verknüpft ist. Dies ist im Wesentlichen das "Passwort" für den Zugriffsschlüssel.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `aws_secret_access_key`. Es ist nicht möglich, die geheime Zugriffsschlüssel-ID als Befehlszeilenoption anzugeben.
**`AWS_SESSION_TOKEN`**
Gibt den Sitzungstokenwert an, der erforderlich ist, wenn Sie temporäre Sicherheitsanmeldeinformationen verwenden, die Sie direkt aus AWS STS -Operationen abgerufen haben. Weitere Informationen finden Sie im [Ausgabeabschnitt des Befehls assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html#output) im *AWS CLI -Befehlsverweis*.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `aws_session_token`.
**`AWS_SHARED_CREDENTIALS_FILE`**
Gibt den Speicherort der Datei an, die zum Speichern von Zugriffsschlüsseln AWS CLI verwendet wird. Der Standardpfad ist `~/.aws/credentials`.
Sie können diesen Wert nicht in einer benannten Profileinstellung oder mithilfe eines Befehlszeilenparameters angeben.
**`AWS_SIGV4A_SIGNING_REGION_SET`**
Gibt mithilfe einer kommagetrennten Liste die Regionen an, die beim Signieren mit SigV4a verwendet werden sollen. Wenn diese Variable nicht gesetzt ist, AWS CLI verwendet der die Standardeinstellung von AWS-Service. Wenn für kein Standardwert angegeben AWS-Service ist, wird die Anforderungssignatur mit dem Wert von in allen Regionen gültig`*`.
Weitere Informationen zu SigV4a finden Sie unter [AWS Signature Version 4 für API-Anforderungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) im *IAM-Benutzerhandbuch*.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung [`sigv4a_signing_region_set`](cli-configure-files.md#cli-config-sigv4a_signing_region_set).
**`AWS_USE_DUALSTACK_ENDPOINT`**
Ermöglicht die Verwendung von Dual-Stack-Endpunkten zum Senden AWS von Anfragen. Weitere Informationen zu Dual-Stack-Endpunkten, die IPv4 sowohl IPv6 Datenverkehr als auch unterstützen, finden Sie unter [Verwenden von Amazon S3 S3-Dual-Stack-Endpunkten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/dual-stack-endpoints.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. Dual-Stack-Endpunkte sind für einige Services in einigen Regionen verfügbar. Wenn kein Dual-Stack-Endpunkt für den Service oder AWS-Region existiert, schlägt die Anfrage fehl. Diese ist standardmäßig deaktiviert. Weitere Informationen finden Sie unter [Stellen Sie ein, dass Dual-Stack-Endpunkte für alle verwendet werden AWS-Services](cli-configure-endpoints.md#endpoints-dual-stack).
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**`AWS_USE_FIPS_ENDPOINT`**
Einige AWS Dienste bieten Endgeräte, die in einigen Fällen den [Federal Information Processing Standard (FIPS) 140-2](https://aws.amazon.com/compliance/fips/) unterstützen. AWS-Regionen Wenn der AWS -Service FIPS unterstützt, gibt diese Einstellung an, welchen FIPS-Endpunkt die AWS CLI verwenden soll. Im Gegensatz zu AWS Standardendpunkten verwenden FIPS-Endpunkte eine TLS-Softwarebibliothek, die FIPS 140-2 entspricht. Diese Endpunkte können von Unternehmen erfordert werden, die mit der US-Regierung interagieren. Weitere Informationen finden Sie unter [So eingestellt, dass FIPs Endpunkte für alle verwendet werden AWS-Services](cli-configure-endpoints.md#endpoints-fips).
Wenn diese Einstellung aktiviert ist, aber kein FIPS-Endpunkt für den Dienst in Ihrem vorhanden ist, schlägt der Befehl möglicherweise fehl. AWS-Region AWS Geben Sie in diesem Fall mithilfe der `--endpoint-url`-Option manuell den Endpunkt an, der im Befehl verwendet werden soll, oder verwenden Sie [servicespezifische Endpunkte](cli-configure-endpoints.md#endpoints-service-specific).
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**[`AWS_WEB_IDENTITY_TOKEN_FILE`](#cli-configure-envvars)**
Gibt den Pfad zu einer Datei an, die ein OAuth 2.0-Zugriffstoken oder ein OpenID Connect-ID-Token enthält, das von einem Identitätsanbieter bereitgestellt wird. Die AWS CLI lädt den Inhalt dieser Datei und übergibt ihn als `WebIdentityToken`-Argument an die Operation `AssumeRoleWithWebIdentity`.
Wird mit `AWS_ROLE_ARN`- und `AWS_ROLE_SESSION_NAME`-Umgebungsvariablen genutzt.
Wenn diese Umgebungsvariable definiert ist, überschreibt sie den Wert der Profileinstellung `web_identity_token_file`.
Weitere Informationen zur Verwendung von Webidentitäten finden Sie unter [Übernehmen einer Rolle mit Web-Identität](cli-configure-role.md#cli-configure-role-oidc).
Diese Umgebungsvariable gilt nur für eine Übernahmerolle mit dem Web-Identitätsanbieter, sie gilt nicht für die allgemeine Konfiguration des Rollenanbieters.
# Befehlszeilenoptionen in der AWS CLI
Bei den Befehlszeilenoptionen handelt es sich um globale Parameter AWS CLI, mit denen Sie die Standardkonfigurationseinstellungen, alle entsprechenden Profileinstellungen oder Umgebungsvariableneinstellungen für diesen einzelnen Befehl außer Kraft setzen können. Sie können mit Befehlszeilenoptionen nicht direkt Anmeldeinformationen angeben. Sie können jedoch angeben, welches Profil verwendet werden soll.
**Topics**
+ [Verwenden von Befehlszeilenoptionen](#cli-configure-options-how)
+ [AWS CLI unterstützte globale Befehlszeilenoptionen](#cli-configure-options-list)
+ [Häufige Verwendungsweisen von Befehlszeilenoptionen](#cli-configure-options-common)
## Verwenden von Befehlszeilenoptionen
Die meisten Befehlszeilenoptionen sind einfache Zeichenfolgen, wie der Profilname `profile1` im folgenden Beispiel:
```
$ aws s3 ls --profile profile1
amzn-s3-demo-bucket1
amzn-s3-demo-bucket2
...
```
Bei jeder Option, für die ein Argument angegeben wird, muss das Argument mit einem Leerzeichen oder Gleichheitszeichen (=) vom Namen der Option getrennt werden. Falls es sich bei dem Argumentwert um eine Zeichenfolge mit einem Leerzeichen handelt, muss das Argument in Anführungszeichen gesetzt werden. Weitere Informationen zu Argumenttypen und zur Formatierung für Parameter finden Sie unter [Angeben von Parameterwerten in der AWS CLI](cli-usage-parameters.md).
## AWS CLI unterstützte globale Befehlszeilenoptionen
In der können AWS CLI Sie die folgenden Befehlszeilenoptionen verwenden, um die Standardkonfigurationseinstellungen, alle entsprechenden Profileinstellungen oder Umgebungsvariableneinstellungen für diesen einzelnen Befehl zu überschreiben.
**--ca-bundle ****
Gibt das Zertifikatspaket der Zertifizierungsstelle an, das beim Überprüfen von SSL-Zertifikaten verwendet werden soll.
Falls definiert, überschreibt diese Option den Wert für die Profileinstellung `ca\$1bundle` und die Umgebungsvariable `AWS\$1CA\$1BUNDLE`.
**--cli-auto-prompt**
Aktiviert den automatischen Prompt-Modus für einen einzelnen Befehl. Wie die folgenden Beispiele zeigen, können Sie es jederzeit angeben.
```
$ aws --cli-auto-prompt
$ aws dynamodb --cli-auto-prompt
$ aws dynamodb describe-table --cli-auto-prompt
```
Diese Option überschreibt die `aws\$1cli\$1auto\$1prompt`-Umgebungsvariable und die Profileinstellung `cli\$1auto\$1prompt`.
Informationen zur automatischen Eingabeaufforderungsfunktion von AWS CLI Version 2 finden Sie unter[Aktivieren und Verwenden von Eingabeaufforderungen in AWS CLI](cli-usage-parameters-prompting.md).
**--cli-binary-format**
Gibt an, wie AWS CLI Version 2 binäre Eingabeparameter interpretiert. Dabei kann es sich um einen der folgenden Werte handeln:
+ **base64** – Dies ist der Standardwert. Ein Eingabeparameter, der als BLOB (Binary Large Object) eingegeben wird, akzeptiert eine base64-kodierte Zeichenfolge. Um echten binären Inhalt zu übergeben, legen Sie den Inhalt in eine Datei und geben den Pfad und den Namen der Datei mit dem Präfix `fileb://` als Wert des Parameters an. Um in einer Datei enthaltenen base64-kodierten Text zu übergeben, geben Sie den Pfad und den Namen der Datei mit dem Präfix `file://` als Wert des Parameters an.
+ **raw-in-base64-out** — Standard für AWS CLI Version 1. Wenn der Wert der Einstellung lautet`raw-in-base64-out`, werden Dateien, auf die mit dem `file://` Präfix verwiesen wird, als Text gelesen. Anschließend werden AWS CLI Versuche, sie binär zu kodieren, gelesen.
Dies überschreibt die Dateikonfigurationseinstellung `cli\$1binary\$1format`.
```
$ aws lambda invoke \
--cli-binary-format raw-in-base64-out \
--function-name my-function \
--invocation-type Event \
--payload '{ "name": "Bob" }' \
response.json
```
Wenn Sie mithilfe der `fileb://` Präfixnotation auf einen Binärwert in einer Datei verweisen, erwartet der AWS CLI *immer*, dass die Datei binären Rohinhalt enthält, und versucht nicht, den Wert zu konvertieren.
Wenn Sie mithilfe der `file://` Präfixnotation auf einen Binärwert in einer Datei verweisen, AWS CLI behandelt der die Datei entsprechend der aktuellen `cli_binary_format` Einstellung. Wenn der Wert dieser Einstellung ist `base64` (der Standardwert, wenn er nicht explizit festgelegt ist), AWS CLI erwartet der, dass die Datei Base64-codierten Text enthält. Wenn der Wert dieser Einstellung `raw-in-base64-out` lautet, erwartet die AWS CLI , dass die Datei unformatierten binären Inhalt enthält.
**--cli-connect-timeout ****
Gibt die maximale Socket-Verbindungszeit in Sekunden an. Wenn als Wert Null (0) festgelegt ist, wartet der Socket-Verbindungsvorgang unbegrenzt (blockiert) und es erfolgt keine Zeitüberschreitung. Der Standardwert liegt bei 60 Sekunden.
**--cli-read-timeout ****
Gibt die maximale Socket-Lesezeit in Sekunden an. Wenn als Wert Null (0) festgelegt ist, wartet der Socket-Lesevorgang unbegrenzt (blockiert) und es erfolgt keine Zeitüberschreitung. Der Standardwert liegt bei 60 Sekunden.
**--color ****
Gibt Unterstützung für die Farbausgabe an. Gültige Werte sind `on`, `off` und `auto`. Der Standardwert ist `auto`.
**--debug**
Ein boolescher Schalter, der die Debug-Protokollierung ermöglicht. AWS CLI Standardmäßig werden in der Befehlsausgabe bereinigte Informationen zu Erfolgen oder Fehlschlägen in Bezug auf die Befehlsergebnisse angezeigt. Die `--debug`-Option stellt die vollständigen Python-Protokolle bereit. Dazu gehören zusätzliche diagnostische `stderr`-Informationen über die Befehlsausführung, die bei der Fehlerbehebung nützlich sein können, um herauszufinden, warum ein Befehl unerwartete Ergebnisse liefert. Um Debug-Protokolle einfach anzuzeigen, empfehlen wir, die Protokolle an eine Datei zu senden, um die Informationen einfacher zu durchsuchen. Sie können dies mit einer der folgenden Methoden durchführen.
Um **nur** die `stderr`-Diagnoseinformationen zu senden, fügen Sie `2> debug.txt` an, wobei `debug.txt` der Name ist, den Sie für Ihre Debug-Datei verwenden möchten:
```
$ aws servicename commandname options --debug 2> debug.txt
```
Um **beide**, die Ausgangs– und `stderr`-Diagnoseinformationen zu senden, fügen Sie `&> debug.txt` an, wobei `debug.txt` der Name ist, den Sie für Ihre Debug-Datei verwenden möchten:
```
$ aws servicename commandname options --debug &> debug.txt
```
**--endpoint-url ****
Gibt die URL an, an die die Anforderung gesendet werden soll. Bei den meisten Befehlen bestimmt der die URL AWS CLI automatisch auf der Grundlage des ausgewählten Dienstes und der angegebenen Region. AWS Allerdings müssen Sie bei einigen Befehlen eine kontenspezifische URL angeben. Sie können einige AWS Dienste auch so konfigurieren, dass sie [einen Endpunkt direkt in Ihrer privaten VPC hosten](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html#what-is-privatelink), der dann möglicherweise angegeben werden muss.
Das folgende Befehlsbeispiel verwendet eine benutzerdefinierte Endpunkt-URL von Amazon S3.
```
$ aws s3 ls --endpoint-url http://localhost:4567
```
**Priorität der Endpunkte**
Die Einstellungen für die Endpunktkonfiguration 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. Der AWS CLI überprüft diese Endpunkteinstellungen in einer bestimmten Reihenfolge und verwendet die Endpunkteinstellung mit der höchsten Priorität. Eine Liste der Endpunktprioritäten finden Sie unter [Priorität der Endpunktkonfiguration und der Einstellungen](cli-configure-endpoints.md#endpoints-precedence).
**--no-cli-auto-prompt**
Deaktiviert den automatischen Eingabeaufforderungsmodus für einen einzelnen Befehl.
```
$ aws dynamodb describe-table --table-name Table1 --no-cli-auto-prompt
```
Diese Option überschreibt die `aws\$1cli\$1auto\$1prompt`-Umgebungsvariable und die Profileinstellung `cli\$1auto\$1prompt`.
Informationen zur automatischen Eingabeaufforderungsfunktion von AWS CLI Version 2 finden Sie unter[Aktivieren und Verwenden von Eingabeaufforderungen in AWS CLI](cli-usage-parameters-prompting.md).
**--no-cli-pager**
Ein boolescher Schalter, der die Verwendung eines Pagers für die Ausgabe des Befehls deaktiviert.
**--no-paginate**
Ein boolescher Schalter, der mehrere Aufrufe deaktiviert, die er automatisch durchführt, um alle Befehlsergebnisse zu empfangen, AWS CLI wodurch eine Seitennummerierung der Ausgabe erzeugt wird. Dies bedeutet, dass nur die erste Seite Ihrer Ausgabe angezeigt wird.
**--no-sign-request**
Ein boolescher Schalter, der das Signieren der HTTP-Anfragen an den Dienstendpunkt deaktiviert. AWS Dadurch wird verhindert, dass Anmeldeinformationen geladen werden.
**--no-verify-ssl**
Standardmäßig AWS CLI verwendet der SSL für die Kommunikation mit Diensten. AWS Für jede SSL-Verbindung und jeden SSL-Anruf AWS CLI überprüft der die SSL-Zertifikate. Bei Verwendung dieser Option wird das Standardverhalten des Überprüfens von SSL-Zertifikaten außer Kraft gesetzt.
Diese Option stellt **keine** bewährte Methode dar. Wenn Sie dies verwenden`--no-verify-ssl`, ist Ihr Datenverkehr zwischen Ihrem Client und den AWS Diensten nicht mehr gesichert. Das bedeutet, dass Ihr Datenverkehr ein Sicherheitsrisiko darstellt und anfällig für man-in-the-middle Exploits ist. Wenn Sie Probleme mit Zertifikaten haben, sollten Sie diese Probleme stattdessen lösen. Informationen zur Behebung von Zertifikatfehlern finden Sie unter [Fehler im Zusammenhang mit SSL-Zertifikaten](cli-chap-troubleshooting.md#tshoot-certificate-verify-failed).
**--Ausgabe ****
Gibt das Ausgabeformat an, das für diesen Befehl verwendet werden soll. Sie können alle folgenden Werte angeben:
+ **[`json`](cli-usage-output-format.md#json-output)** – Die Ausgabe erfolgt im [JSON](https://json.org/)-Format.
+ **[`yaml`](cli-usage-output-format.md#yaml-output)** –Die Ausgabe erfolgt im [YAML](https://yaml.org/)-Format.
+ **[`yaml-stream`](cli-usage-output-format.md#yaml-stream-output)** – Die Ausgabe erfolgt im [YAML](https://yaml.org/)-Format und wird so auch gestreamt. Streaming ermöglicht eine schnellere Handhabung großer Datentypen.
+ **[`text`](cli-usage-output-format.md#text-output)** – Die Ausgabe wird als mehrere Zeilen mit tabulatorgetrennten Zeichenfolgenwerten formatiert. Dies kann nützlich sein, um die Ausgabe an einen Textprozessor wie `grep`, `sed` oder `awk` zu übergeben.
+ **[`table`](cli-usage-output-format.md#table-output)** – Die Ausgabe erfolgt in Form einer Tabelle mit den Zeichen \$1\$1-, um die Zellenrahmen zu bilden. Normalerweise wird die Information in einem benutzerfreundlichen Format wiedergegeben, das viel einfacher zu lesen ist als die anderen, jedoch programmatisch nicht so nützlich ist.
+ **[`off`](cli-usage-output-format.md#off-output)**— Die Ausgabe unterdrückt alle Befehlsausgaben an die Standardausgabe. Dies ist nützlich in Automatisierungsskripten und CI/CD Pipelines, bei denen Sie nur den Exit-Code des Befehls überprüfen müssen, ohne die Ausgabe zu verarbeiten.
**--profile ****
Gibt das [benannte Profil](cli-configure-files.md#cli-configure-files-using-profiles) an, das für diesen Befehl verwendet werden soll. Zum Einrichten weiterer benannter Profile können Sie den Befehl `aws configure` mit der Option `--profile` verwenden.
```
$ aws configure --profile
```
**--abfrage ****
Gibt eine [JMESPath Abfrage](https://jmespath.org/) an, die beim Filtern der Antwortdaten verwendet werden soll. Weitere Informationen finden Sie unter [Ausgabe filtern in AWS CLI](cli-usage-filter.md).
**--region ****
Gibt an, AWS in welche Region die AWS Anfrage dieses Befehls gesendet werden soll. Eine Liste aller Regionen, die Sie angeben können, finden Sie unter [AWS -Regionen und -Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html) im *Allgemeine Amazon Web Services-Referenz*.
**--version**
Ein boolescher Schalter, der die aktuelle Version des laufenden Programms anzeigt. AWS CLI
## Häufige Verwendungsweisen von Befehlszeilenoptionen
Befehlszeilenoptionen werden häufig für die Überprüfung Ihrer Ressourcen in mehreren AWS -Regionen und zur Änderung des Ausgabeformats für bessere Lesbarkeit oder zur einfacheren Skripterstellung verwendet. In den folgenden Beispielen führen wir den Befehl **describe-instances** gegen jede Region aus, bis wir herausfinden, in welcher Region sich unsere Instance befindet.
```
$ aws ec2 describe-instances --output table --region us-west-1
-------------------
|DescribeInstances|
+-----------------+
$ aws ec2 describe-instances --output table --region us-west-2
------------------------------------------------------------------------------
| DescribeInstances |
+----------------------------------------------------------------------------+
|| Reservations ||
|+-------------------------------------+------------------------------------+|
|| OwnerId | 012345678901 ||
|| ReservationId | r-abcdefgh ||
|+-------------------------------------+------------------------------------+|
||| Instances |||
||+------------------------+-----------------------------------------------+||
||| AmiLaunchIndex | 0 |||
||| Architecture | x86_64 |||
...
```
# Konfiguration der Befehlsvervollständigung in AWS CLI
**Das AWS Command Line Interface (AWS CLI) beinhaltet eine Bash-kompatible Funktion zur Befehlsvervollständigung, mit der Sie die Tabulatortaste verwenden können, um einen teilweise eingegebenen Befehl abzuschließen.** Auf den meisten Systemen müssen Sie dies manuell konfigurieren.
Informationen zur automatischen Eingabeaufforderungsfunktion von AWS CLI Version 2 finden Sie stattdessen unter[Aktivieren und Verwenden von Eingabeaufforderungen in AWS CLI](cli-usage-parameters-prompting.md).
**Topics**
+ [Funktionsweise](#cli-command-completion-about)
+ [Konfigurieren der Befehlsvervollständigung unter Linux oder macOS](#cli-command-completion-linux)
+ [Konfigurieren der Befehlsvervollständigung unter Windows](#cli-command-completion-windows)
## Funktionsweise
Wenn Sie einen Befehl, einen Parameter oder eine Option teilweise eingeben, wird der Befehl vom Befehlsvervollständigungs-Feature entweder automatisch vervollständigt oder von dieser eine Liste mit vorgeschlagenen Befehlen angezeigt. Um die Befehlsvervollständigung aufzufordern, geben Sie einen Befehl teilweise ein und drücken dann die Vervollständigungstaste, was normalerweise *Tab* in den meisten Shells der Fall ist.
Die folgenden Beispiele zeigen verschiedene Möglichkeiten, wie Sie die Befehlsvervollständigung nutzen können:
+ Geben Sie einen Befehl teilweise ein und drücken Sie*Tab*, um eine vorgeschlagene Befehlsliste anzuzeigen.
```
$ aws dynamodb dTAB
delete-backup describe-global-table
delete-item describe-global-table-settings
delete-table describe-limits
describe-backup describe-table
describe-continuous-backups describe-table-replica-auto-scaling
describe-contributor-insights describe-time-to-live
describe-endpoints
```
+ Geben Sie einen Parameter teilweise ein und drücken Sie*Tab*, um eine vorgeschlagene Parameterliste anzuzeigen.
```
$ aws dynamodb delete-table --TAB
--ca-bundle --endpoint-url --profile
--cli-connect-timeout --generate-cli-skeleton --query
--cli-input-json --no-paginate --region
--cli-read-timeout --no-sign-request --table-name
--color --no-verify-ssl --version
--debug --output
```
+ Geben Sie einen Parameter ein und drücken Sie*Tab*, um eine vorgeschlagene Liste von Ressourcenwerten anzuzeigen. Diese Funktion ist nur in AWS CLI Version 2 verfügbar.
```
$ aws dynamodb delete-table --table-name TAB
Table 1 Table 2 Table 3
```
## Konfigurieren der Befehlsvervollständigung unter Linux oder macOS
Um die Befehlsvervollständigung unter Linux oder macOS zu konfigurieren, müssen Sie den Namen der verwendeten Shell und den Speicherort des `aws_completer`-Skripts kennen.
**Anmerkung**
Auf Amazon-EC2-Instances, die Amazon Linux ausführen, ist die Befehlsvervollständigung automatisch konfiguriert und standardmäßig aktiviert.
**Topics**
+ [Bestätigen Sie, dass sich der Ordner der Vervollständigung in Ihrem Pfad befindet](#cli-command-completion-path)
+ [Aktivieren der Befehlsvervollständigung](#cli-command-completion-enable)
+ [Verifizieren der Befehlsvervollständigung](#cli-command-completion-test)
### Bestätigen Sie, dass sich der Ordner der Vervollständigung in Ihrem Pfad befindet
Damit der AWS Completer erfolgreich funktioniert, `aws_completer` muss er sich im Pfad Ihrer Shell befinden. Der `which`-Befehl kann überprüfen, ob sich die Vervollständigung in Ihrem Pfad befindet.
```
$ which aws_completer
/usr/local/bin/aws_completer
```
Wenn der Befehl die Vervollständigung nicht finden kann, führen Sie die folgenden Schritte aus, um den Ordner der Vervollständigung zu Ihrem Pfad hinzuzufügen.
#### Schritt 1: Suchen Sie den Completer AWS
Der Standort des AWS Completers kann je nach verwendeter Installationsmethode variieren.
+ **Paketmanager** — Programme wie`pip`, `yum``brew`, und installieren den AWS Completer (oder einen Symlink dazu) `apt-get` normalerweise an einem Standardpfad.
+ Wenn Sie `pip` **ohne** den Parameter `--user` verwendet haben, ist der Standardpfad `/usr/local/bin/aws_completer`.
+ Wenn Sie `pip` **ohne** den Parameter `--user` verwendet haben, ist der Standardpfad `/home/username/.local/bin/aws_completer`.
+ **Gebündeltes Installationsprogramm** – Wenn Sie das mitgelieferte Installationsprogramm verwendet haben, ist der Standardpfad `/usr/local/bin/aws_completer`.
Wenn alles andere fehlschlägt, können Sie den `find` Befehl verwenden, um Ihr Dateisystem nach dem AWS Completer zu durchsuchen.
```
$ find / -name aws_completer
/usr/local/bin/aws_completer
```
#### Schritt 2: Identifizieren Ihrer Shell
Um zu ermitteln, welche Shell Sie verwenden, können Sie einen der folgenden Befehle verwenden.
+ **echo \$1SHELL** – Zeigt den Programmdateinamen der Shell an. Dieser wird in der Regel für die verwendete Shell korrekt sein, sofern Sie keine andere Shell nach dem Anmelden gestartet haben.
```
$ echo $SHELL
/bin/bash
```
+ **ps** – Zeigt die für den aktuellen Benutzer ausgeführten Prozesse an. Einer von ihnen ist die Shell.
```
$ ps
PID TTY TIME CMD
2148 pts/1 00:00:00 bash
8756 pts/1 00:00:00 ps
```
#### Schritt 3: Fügen Sie die Vervollständigung zu Ihrem Pfad hinzu
1. Suchen Sie das Profilskript für die Shell in Ihrem Benutzerordner.
```
$ ls -a ~/
. .. .bash_logout .bash_profile .bashrc Desktop Documents Downloads
```
+ **Bash** – `.bash_profile`, `.profile` oder `.bash_login`
+ **Zsh**– `.zshrc`
+ **Tcsh**– `.tcshrc`, `.cshrc` oder `.login`
1. Fügen Sie einen Exportbefehl an das Ende Ihres Profilskripts hinzu und orientieren Sie sich dabei an folgendem Beispiel. Ersetzen Sie `/usr/local/bin/` durch den Ordner, den Sie im vorherigen Abschnitt entdeckt haben.
```
export PATH=/usr/local/bin/:$PATH
```
1. Laden Sie das Profil erneut in die aktuelle Sitzung, damit die Änderungen wirksam werden. Ersetzen Sie `.bash_profile` durch den Namen des Shell-Skripts, das Sie im ersten Abschnitt entdeckt haben.
```
$ source ~/.bash_profile
```
### Aktivieren der Befehlsvervollständigung
Nachdem Sie bestätigt haben, dass sich die Vervollständigung in Ihrem Pfad befindet, aktivieren Sie die Befehlsvervollständigung, indem Sie den entsprechenden Befehl für die von Ihnen verwendete Shell ausführen. Sie können den Befehl des Profils Ihrer Shell hinzufügen, sodass er immer ausgeführt wird, wenn Sie eine neue Shell öffnen. Ersetzen Sie in jedem Befehl den Pfad durch den */usr/local/bin/* Pfad, den Sie auf Ihrem System unter finden. [Bestätigen Sie, dass sich der Ordner der Vervollständigung in Ihrem Pfad befindet](#cli-command-completion-path)
+ **`bash`** – Verwenden Sie den integrierten Befehl `complete`.
```
$ complete -C '/usr/local/bin/aws_completer' aws
```
Fügen Sie den vorherigen Befehl `~/.bashrc` hinzu, sodass er immer ausgeführt wird, wenn Sie eine neue Shell öffnen. Ihr `~/.bash_profile` sollte `~/.bashrc` bereitstellen, um sicherzustellen, dass der Befehl auch in Anmelde-Shells ausgeführt wird.
+ **`zsh`** – Um die Befehlsvervollständigung auszuführen, müssen Sie `bashcompinit` ausführen, indem Sie die folgende Autoload-Zeile am Ende Ihres `~/.zshrc`-Profilskripts hinzufügen.
```
$ autoload bashcompinit && bashcompinit
$ autoload -Uz compinit && compinit
```
Um die Befehlsvervollständigung zu aktivieren, verwenden Sie den integrierten Befehl `complete`.
```
$ complete -C '/usr/local/bin/aws_completer' aws
```
Fügen Sie die vorherigen Befehle `~/.zshrc` hinzu, sodass sie immer ausgeführt werden, wenn Sie eine neue Shell öffnen.
+ **`tcsh`** – Die Vervollständigung für `tcsh` erwartet einen Worttyp und ein Muster, um das Vervollständigungsverhalten zu definieren.
```
> complete aws 'p/*/`aws_completer`/'
```
Fügen Sie den vorherigen Befehl `~/.tcshrc` hinzu, sodass er immer ausgeführt wird, wenn Sie eine neue Shell öffnen.
Nachdem Sie die Befehlsvervollständigung aktiviert haben, funktioniert [Verifizieren der Befehlsvervollständigung](#cli-command-completion-test).
### Verifizieren der Befehlsvervollständigung
Nachdem Sie die Befehlsvervollständigung aktiviert haben, laden Sie Ihre Shell neu, geben Sie einen Teilbefehl ein und drücken Sie die **Tab**-Taste, um die verfügbaren Befehle anzuzeigen.
```
$ aws sTAB
s3 ses sqs sts swf
s3api sns storagegateway support
```
## Konfigurieren der Befehlsvervollständigung unter Windows
**Anmerkung**
*Informationen dazu, wie PowerShell mit ihrer Vervollständigung umgegangen wird, einschließlich ihrer verschiedenen Vervollständigungsschlüssel, finden Sie unter [about\$1Tab\$1Expansion](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_tab_expansion) in den Microsoft Docs. PowerShell*
Um die Befehlsvervollständigung für PowerShell unter Windows zu aktivieren, führen Sie die folgenden Schritte unter aus. PowerShell
1. Öffnen Sie Ihr `$PROFILE` mit dem folgenden Befehl.
```
PS C:\> Notepad $PROFILE
```
Wenn Sie kein `$PROFILE` haben, erstellen Sie mit dem folgenden Befehl ein Benutzerprofil.
```
PS C:\> if (!(Test-Path -Path $PROFILE ))
{ New-Item -Type File -Path $PROFILE -Force }
```
Weitere Informationen zu PowerShell Profilen finden Sie unter [So verwenden Sie Profile in Windows PowerShell ISE](https://docs.microsoft.com/en-us/powershell/scripting/windows-powershell/ise/how-to-use-profiles-in-windows-powershell-ise) auf der *Microsoft Docs-Website*.
1. Um die Befehlsvervollständigung zu aktivieren, fügen Sie dem Profil den folgenden Codeblock hinzu, speichern und schließen Sie die Datei.
```
Register-ArgumentCompleter -Native -CommandName aws -ScriptBlock {
param($commandName, $wordToComplete, $cursorPosition)
$env:COMP_LINE=$wordToComplete
if ($env:COMP_LINE.Length -lt $cursorPosition){
$env:COMP_LINE=$env:COMP_LINE + " "
}
$env:COMP_POINT=$cursorPosition
aws_completer.exe | ForEach-Object {
[System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
}
Remove-Item Env:\COMP_LINE
Remove-Item Env:\COMP_POINT
}
```
1. Nachdem Sie die Befehlsvervollständigung aktiviert haben, laden Sie Ihre Shell neu, geben Sie einen Teilbefehl ein und drücken Sie die **Tab**-Taste, um die verfügbaren Befehle zu durchlaufen.
```
$ aws sTab
```
```
$ aws s3
```
Um alle verfügbaren Befehle zu sehen, die zur Vervollständigung verfügbar sind, geben Sie einen Teil eines Befehls ein und drücken Sie **Strg** \$1 **Leerzeichen**.
```
$ aws sCtrl + Space
s3 ses sqs sts swf
s3api sns storagegateway support
```
# AWS CLI Wiederholungen in der AWS CLI
In diesem Thema wird beschrieben, wie Aufrufe von AWS Diensten AWS CLI möglicherweise aufgrund unerwarteter Probleme fehlschlagen. Diese Probleme können serverseitig auftreten oder auf eine Ratenbegrenzung des AWS -Services, den Sie aufrufen möchten, zurückzuführen sein. Solche Ausfälle erfordern in der Regel keine besondere Behandlung und der Aufruf wird, oft nach einer kurzen Wartezeit, automatisch erneut getätigt. Das AWS CLI bietet viele Funktionen, mit denen Sie versuchen können, Kundenanrufe bei AWS Diensten zu wiederholen, wenn diese Art von Fehlern oder Ausnahmen auftreten.
**Topics**
+ [Verfügbare Wiederholungsmodi](#cli-usage-retries-modes)
+ [Konfigurieren eines Wiederholungsversuchsmodus](#cli-usage-retries-configure)
+ [Anzeigen von Protokollen von Wiederholungsversuchen](#cli-usage-retries-validate)
## Verfügbare Wiederholungsmodi
**Topics**
+ [Standard-Wiederholungsmodus(Standard)](#cli-usage-retries-modes-standard.title)
+ [Legacy-Wiederholungsmodus](#cli-usage-retries-legacy)
+ [Adaptiver Wiederholungsmodus](#cli-usage-retries-modes-adaptive)
### Standard-Wiederholungsmodus(Standard)
`Standard`Der Modus ist ein Standardsatz von Wiederholungsregeln für das gesamte System AWS SDKs mit mehr Funktionen als der Vorgängermodus und ist der Standardmodus, für AWS CLI den er standardmäßig verwendet wird. Der Standardmodus wurde für AWS CLI Version 2 erstellt und auf AWS CLI Version 1 zurückportiert. Die Funktionalität des Standardmodus umfasst:
+ Ein Standardwert von 2 für maximale Wiederholungsversuche, was insgesamt 3 Anrufversuche ergibt. Dieser Wert kann durch den Konfigurationsparameter `max_attempts` überschrieben werden.
+ Wiederholungsversuche für die folgende erweiterte Liste mit Fehlern/Ausnahmen:
+ Transiente Fehler/Ausnahmen
+ `RequestTimeout`
+ `RequestTimeoutException`
+ `PriorRequestNotComplete`
+ `ConnectionError`
+ `HTTPClientError`
+ throttling/limit Fehler und Ausnahmen auf der Serviceseite:
+ `Throttling`
+ `ThrottlingException`
+ `ThrottledException`
+ `RequestThrottledException`
+ `TooManyRequestsException`
+ `ProvisionedThroughputExceededException`
+ `TransactionInProgressException`
+ `RequestLimitExceeded`
+ `BandwidthLimitExceeded`
+ `LimitExceededException`
+ `RequestThrottled`
+ `SlowDown`
+ `EC2ThrottledException`
+ Wiederholungsversuche für nicht beschreibende, transiente Fehlercodes. Insbesondere diese HTTP-Statuscodes: 500, 502, 503, 504.
+ Jeder Wiederholungsversuch beinhaltet ein exponentielles Backoff um einen Basisfaktor von 2 für eine maximale Backoff-Zeit von 20 Sekunden.
### Legacy-Wiederholungsmodus
Der `Legacy`-Modus verwendet einen älteren Wiederholungs-Handler mit eingeschränkter Funktionalität, der Folgendes umfasst:
+ Einen Standardwert von 4 für maximale Wiederholungsversuche, was insgesamt 5 Aufrufversuche ergibt. Dieser Wert kann durch den Konfigurationsparameter `max_attempts` überschrieben werden.
+ Dynamo DB hat einen Standardwert von 9 für maximale Wiederholungsversuche, was insgesamt 10 Aufrufversuche ergibt. Dieser Wert kann durch den Konfigurationsparameter `max_attempts` überschrieben werden.
+ Wiederholungsversuche für die folgende begrenzte Anzahl von Fehlern/Ausnahmen:
+ Allgemeine socket/connection Fehler:
+ `ConnectionError`
+ `ConnectionClosedError`
+ `ReadTimeoutError`
+ `EndpointConnectionError`
+ throttling/limit Fehler und Ausnahmen auf der Serviceseite:
+ `Throttling`
+ `ThrottlingException`
+ `ThrottledException`
+ `RequestThrottledException`
+ `ProvisionedThroughputExceededException`
+ Wiederholungsversuche für mehrere HTTP-Statuscodes, einschließlich 429, 500, 502, 503, 504 und 509.
+ Jeder Wiederholungsversuch enthält ein exponentielles Backoff um den Basisfaktor 2.
### Adaptiver Wiederholungsmodus
**Warnung**
Der adaptive Modus ist ein experimenteller Modus und kann sich sowohl in den Features als auch im Verhalten ändern.
Der `Adaptive`-Wiederholungsmodus ist ein experimenteller Wiederholungsmodus, der alle Features des Standardmodus enthält. Zusätzlich zu den Standardmodus-Features führt der adaptive Modus auch die clientseitige Ratenbegrenzung durch die Verwendung eines Token-Buckets und Ratenbegrenzungsvariablen ein, die bei jedem Wiederholungsversuch dynamisch aktualisiert werden. Dieser Modus bietet Flexibilität bei clientseitigen Wiederholungsversuchen und passt sich an die error/exception Statusantwort eines Dienstes an. AWS
Bei jedem neuen Wiederholungsversuch ändert der adaptive Modus die Variablen für die Ratenbegrenzung auf der Grundlage des in der Antwort des Dienstes angegebenen Fehler-, Ausnahme- oder HTTP-Statuscode. AWS Diese Ratenbegrenzungsvariablen werden dann verwendet, um eine neue Aufrufrate für den Client zu berechnen. Bei jeder HTTP-Antwort exception/error oder bei jeder erfolglosen HTTP-Antwort (siehe Liste oben) eines AWS Dienstes werden die Variablen für die Ratenbegrenzung bei Wiederholungen aktualisiert, bis der Erfolg erreicht ist, der Token-Bucket erschöpft ist oder der konfigurierte Wert für maximale Versuche erreicht ist.
## Konfigurieren eines Wiederholungsversuchsmodus
AWS CLI Dazu gehören eine Vielzahl von Wiederholungskonfigurationen und Konfigurationsmethoden, die Sie bei der Erstellung Ihres Client-Objekts berücksichtigen sollten.
### Verfügbare Konfigurationsmethoden
In der AWS CLI können Benutzer Wiederholungsversuche auf folgende Weise konfigurieren:
+ Umgebungsvariablen
+ AWS CLI Konfigurationsdatei
Die folgenden Optionen für Wiederholungsversuche können angepasst werden:
+ Wiederholungsmodus — Gibt an, welchen Wiederholungsmodus der AWS CLI Benutzer verwendet. Wie zuvor beschrieben, stehen drei Wiederholungsmodi zur Verfügung: Legacy, Standard und Adaptive. Der Standardwert für 2 ist Standard.
+ Max. Versuche — Gibt den Wert der maximalen Anzahl von Wiederholungsversuchen an, die der AWS CLI Wiederholungshandler verwendet, wobei der erste Aufruf auf den von Ihnen angegebenen Wert angerechnet wird. Der Standardwert basiert auf Ihrem Wiederholungsmodus.
### Definieren einer Wiederholungskonfiguration in Ihren Umgebungsvariablen
Um Ihre Wiederholungskonfiguration für zu definieren AWS CLI, aktualisieren Sie die Umgebungsvariablen Ihres Betriebssystems.
Die Umgebungsvariablen für den Wiederholungsversuch sind:
+ `AWS_RETRY_MODE`
+ `AWS_MAX_ATTEMPTS`
Weitere Informationen zu Umgebungsvariablen finden Sie unter [Konfiguration von Umgebungsvariablen für AWS CLI](cli-configure-envvars.md).
### Definieren Sie eine Wiederholungskonfiguration in Ihrer AWS Konfigurationsdatei
Um Ihre Wiederholungskonfiguration zu ändern, aktualisieren Sie Ihre globale AWS Konfigurationsdatei. Der Standardspeicherort für Ihre AWS Konfigurationsdatei ist \$1/.aws/config.
Im Folgenden finden Sie ein Beispiel für eine Konfigurationsdatei: AWS
```
[default]
retry_mode = standard
max_attempts = 6
```
Weitere Informationen zu Konfigurationsdateien finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
## Anzeigen von Protokollen von Wiederholungsversuchen
Das AWS CLI verwendet die Wiederholungsmethode und Protokollierung von Boto3. Sie können die `--debug`-Option für einen beliebigen Befehl benutzen, um Debug-Protokolle zu empfangen. Weitere Informationen zur Verwendung der Option `--debug` finden Sie unter [Befehlszeilenoptionen in der AWS CLI](cli-configure-options.md).
Wenn Sie in den Debug-Protokollen nach „retry“ suchen, finden Sie die erforderlichen Wiederholungsinformationen. Die Clientprotokolleinträge für Wiederholungsversuche hängen davon ab, welchen Wiederholungsmodus Sie aktiviert haben.
**Legacy-Modus:**
Wiederholungsmeldungen werden von botocore.retryhandler generiert. Es wird eine von drei Meldungen angezeigt:
+ `No retry needed`
+ `Retry needed, action of: `
+ `Reached the maximum number of retry attempts: `
**Standard- oder adaptiver Modus:**
Wiederholungsmeldungen werden von botocore.retries.standard generiert. Es wird eine von drei Meldungen angezeigt:
+ `No retrying request`
+ `Retry needed, retrying request after delay of: `
+ `Retry needed but retry quota reached, not retrying request`
[https://github.com/boto/botocore/blob/develop/botocore/data/_retry.json](https://github.com/boto/botocore/blob/develop/botocore/data/_retry.json)
# Verwenden eines HTTP-Proxy für die AWS CLI
Um über Proxy-Server auf AWS zuzugreifen, können Sie die Umgebungsvariablen `HTTP_PROXY` und `HTTPS_PROXY` mit den DNS-Domainnamen oder IP-Adressen und Portnummern konfigurieren, die Ihre Proxy-Server verwenden.
**Topics**
+ [Verwenden der -Beispiele](#cli-configure-proxy-using)
+ [Authentifizieren bei einem Proxy](#cli-configure-proxy-auth)
+ [Verwenden von Proxys auf Amazon-EC2-Instances](#cli-configure-proxy-ec2)
+ [Fehlersuche](#cli-configure-proxy-tshoot)
## Verwenden der -Beispiele
**Anmerkung**
Die folgenden Beispiele zeigen den Namen der Umgebungsvariablen in Großbuchstaben. Wenn Sie jedoch zweimal eine Variable in Groß- und in Kleinbuchstaben angeben, haben die Kleinbuchstaben Vorrang. Wir empfehlen, jede Variable nur einmal zu definieren, um Verwirrung und unerwartetes Verhalten zu vermeiden.
Die folgenden Beispiele zeigen, wie Sie entweder die explizite IP-Adresse Ihres Proxys oder einen DNS-Namen verwenden können, der in die IP-Adresse Ihres Proxys aufgelöst wird. In beiden Fällen können ein Doppelpunkt und die Portnummer folgen, an die Abfragen gesendet werden sollen.
------
#### [ Linux or macOS ]
```
$ export HTTP_PROXY=http://10.15.20.25:1234
$ export HTTP_PROXY=http://proxy.example.com:1234
$ export HTTPS_PROXY=http://10.15.20.25:5678
$ export HTTPS_PROXY=http://proxy.example.com:5678
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx HTTP_PROXY http://10.15.20.25:1234
C:\> setx HTTP_PROXY http://proxy.example.com:1234
C:\> setx HTTPS_PROXY http://10.15.20.25:5678
C:\> setx HTTPS_PROXY http://proxy.example.com:5678
```
Bei Verwendung von [https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx) zur Festlegung einer Umgebungsvariablen wird der verwendete Wert in der aktuellen Eingabeaufforderungssitzung und allen nach Ausführung des Befehls erstellten Eingabeaufforderungssitzungen geändert. Andere Befehls-Shells, die zum Zeitpunkt der Befehlsausführung bereits ausgeführt werden, sind hiervon ***nicht*** betroffen.
**Einrichten nur für die aktuelle Sitzung**
Bei Verwendung von `[set](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/set_1)` zur Festlegung einer Umgebungsvariablen wird der verwendete Wert bis zum Ende der aktuellen Eingabeaufforderungssitzung oder bis zur Festlegung eines anderen Wertes für die Variable geändert.
```
C:\> set HTTP_PROXY=http://10.15.20.25:1234
C:\> set HTTP_PROXY=http://proxy.example.com:1234
C:\> set HTTPS_PROXY=http://10.15.20.25:5678
C:\> set HTTPS_PROXY=http://proxy.example.com:5678
```
------
## Authentifizieren bei einem Proxy
**Anmerkung**
Die AWS CLI unterstützt keine NTLM-Proxys. Wenn Sie einen NTLM- oder Kerberos-Protokoll-Proxy verwenden, können Sie möglicherweise eine Verbindung über einen Authentifizierungs-Proxy wie [Cntlm](http://cntlm.sourceforge.net) herstellen.
Die AWS CLI unterstützt HTTP-Standardauthentifizierung. Geben Sie den Benutzernamen und das Passwort folgendermaßen in die Proxy-URL ein.
------
#### [ Linux or macOS ]
```
$ export HTTP_PROXY=http://username:password@proxy.example.com:1234
$ export HTTPS_PROXY=http://username:password@proxy.example.com:5678
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx HTTP_PROXY http://username:password@proxy.example.com:1234
C:\> setx HTTPS_PROXY http://username:password@proxy.example.com:5678
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set HTTP_PROXY=http://username:password@proxy.example.com:1234
C:\> set HTTPS_PROXY=http://username:password@proxy.example.com:5678
```
------
## Verwenden von Proxys auf Amazon-EC2-Instances
Wenn Sie einen Proxy auf einer Amazon-EC2-Instance konfigurieren, die mit einer zugeordneten IAM-Rolle gestartet wurde, stellen Sie sicher, dass Sie die Adresse für den Zugriff auf die [Instance-Metadaten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) ausnehmen. Legen Sie dazu die Umgebungsvariable `NO_PROXY` auf die IP-Adresse des Instance-Metadaten-Services, 169.254.169.254, fest. Diese Adresse variiert nicht.
------
#### [ Linux or macOS ]
```
$ export NO_PROXY=169.254.169.254
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx NO_PROXY 169.254.169.254
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set NO_PROXY=169.254.169.254
```
------
## Fehlersuche
Wenn Fehler auftretenAWS CLI, finden Sie unter Informationen[Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) zur Fehlerbehebung. Die wichtigsten Maßnahmen zur Fehlerbehebung finden Sie unter [Fehler im Zusammenhang mit SSL-Zertifikaten](cli-chap-troubleshooting.md#tshoot-certificate-verify-failed).
# Verwenden von Endpunkten in der AWS CLI
Um programmgesteuert eine Verbindung zu einem herzustellen AWS-Service, verwenden Sie einen Endpunkt. Ein *Endpunkt* ist die URL des Einstiegspunkts für einen AWS Webdienst. Die AWS Command Line Interface (AWS CLI) verwendet automatisch den Standardendpunkt für jeden Dienst in einem AWS-Region, aber Sie können einen alternativen Endpunkt für Ihre API-Anfragen angeben.
**Contents**
+ [Festlegen eines Endpunkts für einen einzelnen Befehl](#endpoints-command)
+ [Legen Sie den globalen Endpunkt für alle fest AWS-Services](#endpoints-global)
+ [So eingestellt, dass FIPs Endpunkte für alle verwendet werden AWS-Services](#endpoints-fips)
+ [Stellen Sie ein, dass Dual-Stack-Endpunkte für alle verwendet werden AWS-Services](#endpoints-dual-stack)
+ [Festlegen servicespezifischer Endpunkte](#endpoints-service-specific)
+ [Umgebungsvariablen](#endpoints-service-specific-envvars)
+ [Freigegebene `config`-Datei](#endpoints-service-specific-config)
+ [Liste der servicespezifischen Kennungen](#endpoints-service-specific-table)
+ [Kontobasierte Endpunkte](#endpoints-accountid)
+ [Priorität der Endpunktkonfiguration und der Einstellungen](#endpoints-precedence)
## Festlegen eines Endpunkts für einen einzelnen Befehl
Verwenden Sie die Befehlszeilenoption `--endpoint-url`, um Endpunkteinstellungen oder Umgebungsvariablen für einen einzelnen Befehl zu überschreiben. Das folgende Befehlsbeispiel verwendet eine benutzerdefinierte Endpunkt-URL von Amazon S3.
```
$ aws s3 ls --endpoint-url http://localhost:4567
```
## Legen Sie den globalen Endpunkt für alle fest AWS-Services
Verwenden Sie eine der folgenden Einstellungen, um Anforderungen für alle Services an eine benutzerdefinierte Endpunkt-URL weiterzuleiten:
+ Umgebungsvariablen:
+ `AWS\$1IGNORE\$1CONFIGURED\$1ENDPOINT\$1URLS`- Ignoriere den konfigurierten Endpunkt URLs.
------
#### [ Linux or macOS ]
```
$ export AWS_IGNORE_CONFIGURED_ENDPOINT_URLS=true
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx AWS_IGNORE_CONFIGURED_ENDPOINT_URLS true
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set AWS_IGNORE_CONFIGURED_ENDPOINT_URLS=true
```
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_IGNORE_CONFIGURED_ENDPOINT_URLS="true"
```
------
+ `AWS\$1ENDPOINT\$1URL` – Legen Sie eine globale Endpunkt-URL fest.
------
#### [ Linux or macOS ]
```
$ export AWS_ENDPOINT_URL=http://localhost:4567
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx AWS_ENDPOINT_URL http://localhost:4567
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set AWS_ENDPOINT_URL=http://localhost:4567
```
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_ENDPOINT_URL="http://localhost:4567"
```
------
+ Die Datei `config`:
+ `ignore\$1configure\$1endpoint\$1urls`- Ignoriert den konfigurierten Endpunkt URLs.
```
ignore_configure_endpoint_urls = true
```
+ `endpoint\$1url` – Legen Sie eine globale Endpunkt-URL fest.
```
endpoint_url = http://localhost:4567
```
Servicespezifische Endpunkte und die Befehlszeilenoption `--endpoint-url` haben Vorrang vor allen globalen Endpunkten.
## So eingestellt, dass FIPs Endpunkte für alle verwendet werden AWS-Services
Verwenden Sie eine der folgenden Methoden, um Anfragen für alle Dienste zur Verwendung von FIPs Endpunkten weiterzuleiten:
+ `AWS\$1USE\$1FIPS\$1ENDPOINT`-Umgebungsvariable.
------
#### [ Linux or macOS ]
```
$ export AWS_USE_FIPS_ENDPOINT=true
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx AWS_USE_FIPS_ENDPOINT true
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set AWS_USE_FIPS_ENDPOINT=true
```
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_USE_FIPS_ENDPOINT="true"
```
------
+ `use\$1fips\$1endpoint`-Dateieinstellung.
```
use_fips_endpoint = true
```
Einige AWS Dienste bieten Endgeräte, die in einigen Fällen den [Federal Information Processing Standard (FIPS) 140-2](https://aws.amazon.com/compliance/fips/) unterstützen. AWS-Regionen Wenn der AWS Dienst FIPS unterstützt, gibt diese Einstellung an, welchen FIPS-Endpunkt verwendet werden soll. AWS CLI Im Gegensatz zu Standard- AWS -Endpunkten verwenden FIPS-Endpunkte eine TLS-Softwarebibliothek, die den Standard FIPS 140-2 erfüllt. Diese Endpunkte können von Unternehmen erfordert werden, die mit der US-Regierung interagieren.
Wenn diese Einstellung aktiviert ist, aber kein FIPS-Endpunkt für den Dienst in Ihrem vorhanden ist AWS-Region, schlägt der AWS Befehl möglicherweise fehl. Geben Sie in diesem Fall mithilfe der `--endpoint-url`-Option manuell den Endpunkt an, der im Befehl verwendet werden soll, oder verwenden Sie [servicespezifische Endpunkte](#endpoints-service-specific).
Weitere Informationen zur Angabe von FIPS-Endpunkten durch finden Sie unter [FIPS-Endpunkte](https://aws.amazon.com/compliance/fips/) nach AWS-Region Dienst.
## Stellen Sie ein, dass Dual-Stack-Endpunkte für alle verwendet werden AWS-Services
Verwenden Sie eine der folgenden Einstellungen, um Anforderungen für alle Services so weiterzuleiten, dass Dual-Stack-Endpunkte verwendet werden:
+ `AWS\$1USE\$1DUALSTACK\$1ENDPOINT`-Umgebungsvariable.
------
#### [ Linux or macOS ]
```
$ export AWS_USE_DUALSTACK_ENDPOINT=true
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx AWS_USE_DUALSTACK_ENDPOINT true
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set AWS_USE_DUALSTACK_ENDPOINT=true
```
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_USE_DUALSTACK_ENDPOINT="true"
```
------
+ `use\$1dualstack\$1endpoint`-Dateieinstellung.
```
use_dualstack_endpoint = true
```
Ermöglicht die Verwendung von Dual-Stack-Endpunkten zum Senden von Anfragen. AWS Weitere Informationen zu Dual-Stack-Endpunkten, die IPv4 sowohl IPv6 Datenverkehr als auch unterstützen, finden Sie unter [Verwenden von Amazon S3 S3-Dual-Stack-Endpunkten](https://docs.aws.amazon.com/AmazonS3/latest/userguide/dual-stack-endpoints.html) im *Amazon Simple Storage Service-Benutzerhandbuch*. Dual-Stack-Endpunkte sind für einige Services in einigen Regionen verfügbar. Wenn kein Dual-Stack-Endpunkt für den Service oder AWS-Region existiert, schlägt die Anfrage fehl. Diese ist standardmäßig deaktiviert.
## Festlegen servicespezifischer Endpunkte
Die dienstspezifische Endpunktkonfiguration bietet die Möglichkeit, einen persistenten Endpunkt Ihrer Wahl für AWS CLI Anfragen zu verwenden. Diese Einstellungen bieten Flexibilität bei der Unterstützung lokaler Endpunkte, VPC-Endpunkte und lokaler AWS Entwicklungsumgebungen von Drittanbietern. Verschiedene Endpunkte können für Test- und Produktionsumgebungen verwendet werden. Sie können eine Endpunkt-URL für einzelne AWS-Services angeben.
Servicespezifische Endpunkte können wie folgt festgelegt werden:
+ Mit der Befehlszeilenoption `--endpoint-url` für einen einzelnen Befehl.
+ Umgebungsvariablen:
+ `AWS\$1IGNORE\$1CONFIGURED\$1ENDPOINT\$1URLS`- Ignoriert alle konfigurierten Endpunkte URLs, sofern sie nicht in der Befehlszeile angegeben wurden.
+ `AWS\$1ENDPOINT\$1URL\$1` – Gibt einen benutzerdefinierten Endpunkt an, der für einen bestimmten Service verwendet wird, wobei `` durch die AWS-Service -Kennung ersetzt wird. Informationen zu allen servicespezifischen Variablen finden Sie unter [Servicespezifische Endpunkte: Liste servicespezifischer Kennungen](#endpoints-service-specific-table).
+ `config`-Datei:
+ `ignore\$1configure\$1endpoint\$1urls`- Ignoriert alle konfigurierten Endpunkte URLs, sofern sie nicht mithilfe von Umgebungsvariablen oder in der Befehlszeile angegeben wurden.
+ Der Abschnitt [`services`](cli-configure-files.md#cli-configure-files-format-services) der `config`-Datei in Kombination mit der Dateieinstellung `endpoint\$1url`.
**Topics**
+ [Umgebungsvariablen](#endpoints-service-specific-envvars)
+ [Freigegebene `config`-Datei](#endpoints-service-specific-config)
+ [Liste der servicespezifischen Kennungen](#endpoints-service-specific-table)
### Servicespezifische Endpunkte: Umgebungsvariablen
Umgebungsvariablen überschreiben die Einstellungen in Ihrer Konfigurationsdatei, aber nicht die in der Befehlszeile angegebenen Optionen. Verwenden Sie Umgebungsvariablen, wenn Sie möchten, dass alle Profile dieselben Endpunkte auf Ihrem Gerät verwenden.
Die folgenden Umgebungsvariablen sind servicespezifisch:
+ `AWS\$1IGNORE\$1CONFIGURED\$1ENDPOINT\$1URLS`- Ignoriert alle konfigurierten Endpunkte URLs, sofern sie nicht in der Befehlszeile angegeben wurden.
------
#### [ Linux or macOS ]
```
$ export AWS_IGNORE_CONFIGURED_ENDPOINT_URLS=true
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx AWS_IGNORE_CONFIGURED_ENDPOINT_URLS true
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set AWS_IGNORE_CONFIGURED_ENDPOINT_URLS=true
```
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_IGNORE_CONFIGURED_ENDPOINT_URLS="true"
```
------
+ `AWS\$1ENDPOINT\$1URL\$1`- Gibt einen benutzerdefinierten Endpunkt an, der für einen bestimmten Dienst verwendet `` wird, wobei dieser durch den AWS-Service Bezeichner ersetzt wird. Informationen zu allen servicespezifischen Variablen finden Sie unter [Servicespezifische Endpunkte: Liste servicespezifischer Kennungen](#endpoints-service-specific-table).
In den folgenden Beispielen für Umgebungsvariablen wird ein Endpunkt für AWS Elastic Beanstalk festgelegt:
------
#### [ Linux or macOS ]
```
$ export AWS_ENDPOINT_URL_ELASTIC_BEANSTALK=http://localhost:4567
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx AWS_ENDPOINT_URL_ELASTIC_BEANSTALK http://localhost:4567
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set AWS_ENDPOINT_URL_ELASTIC_BEANSTALK=http://localhost:4567
```
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_ENDPOINT_URL_ELASTIC_BEANSTALK="http://localhost:4567"
```
------
Weitere Informationen zum Festlegen von Umgebungsvariablen finden Sie unter [Konfiguration von Umgebungsvariablen für AWS CLI](cli-configure-envvars.md).
### Servicespezifische Endpunkte: freigegebene `config`-Datei
In der freigegebenen `config`-Datei wird `endpoint_url` in mehreren Abschnitten verwendet. Wenn Sie einen servicespezifischen Endpunkt festlegen möchten, verwenden Sie die Einstellung `endpoint_url`, die unter einem Service-ID-Schlüssel innerhalb eines `services`-Abschnitts verschachtelt ist. Details zur Definition eines `services`-Abschnitts in Ihrer freigegebenen `config`-Datei finden Sie unter [Abschnittstyp: `services`](cli-configure-files.md#cli-configure-files-format-services).
Das folgende Beispiel verwendet einen `services`-Abschnitt zur Konfiguration einer servicespezifischen Endpunkt-URL für Amazon S3 und eines benutzerdefinierten globalen Endpunkts, der für alle anderen Services verwendet wird:
```
[profile dev1]
endpoint_url = http://localhost:1234
services = s3-specific
[services testing-s3]
s3 =
endpoint_url = http://localhost:4567
```
Mit einem einzigen Profil können Endpunkte für mehrere Services konfiguriert werden. Im folgenden Beispiel wird der dienstspezifische Endpunkt URLs für Amazon S3 und AWS Elastic Beanstalk im selben Profil festgelegt.
Eine Liste aller Service-ID-Schlüssel, die im `services`-Abschnitt verwendet werden können, finden Sie unter [Liste der servicespezifischen Kennungen](#endpoints-service-specific-table).
```
[profile dev1]
services = testing-s3-and-eb
[services testing-s3-and-eb]
s3 =
endpoint_url = http://localhost:4567
elastic_beanstalk =
endpoint_url = http://localhost:8000
```
Der Abschnitt zur Servicekonfiguration kann in mehreren Profilen verwendet werden. Im folgenden Beispiel verwenden zwei Profile dieselbe `services`-Definition:
```
[profile dev1]
output = json
services = testing-s3
[profile dev2]
output = text
services = testing-s3
[services testing-s3]
s3 =
endpoint_url = https://localhost:4567
```
### Servicespezifische Endpunkte: Liste servicespezifischer Kennungen
Der AWS-Service Bezeichner basiert auf dem API-Modell, indem alle Leerzeichen `serviceId` durch Unterstriche ersetzt und alle Buchstaben klein geschrieben werden.
In der folgenden Tabelle sind alle servicespezifischen Kennungen, `config`-Dateischlüssel und Umgebungsvariablen aufgeführt.
## Kontobasierte Endpunkte
Kontobasierte Endpunkte können wie folgt festgelegt werden:
+ Umgebungsvariablen
+ `AWS\$1ACCOUNT\$1ID` – Gibt die AWS -kontobasierte Endpunkt-ID an, die für Aufrufe an unterstützte AWS-Services verwendet werden soll.
------
#### [ Linux or macOS ]
```
$ export AWS_ACCOUNT_ID=
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx AWS_ACCOUNT_ID
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set AWS_ACCOUNT_ID=
```
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_ACCOUNT_ID=""
```
------
+ `AWS\$1ACCOUNT\$1ID\$1ENDPOINT\$1MODE`— Gibt an, ob ein AWS kontobasierter Endpunkt IDs für Anrufe an den Support verwendet werden soll. AWS-Services Mögliche Einstellungen sind `preferred`, `disabled` oder `required`. Der Standardwert ist `preferred`.
------
#### [ Linux or macOS ]
```
$ export AWS_ACCOUNT_ID_ENDPOINT_MODE=preferred
```
------
#### [ Windows Command Prompt ]
**Einrichten für alle Sitzungen**
```
C:\> setx AWS_ACCOUNT_ID_ENDPOINT_MODE preferred
```
**Einrichten nur für die aktuelle Sitzung**
```
C:\> set AWS_ACCOUNT_ID_ENDPOINT_MODE=preferred
```
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_ACCOUNT_ID_ENDPOINT_MODE="preferred"
```
------
+ Die Datei `config`:
+ `aws\$1account\$1id`- Gibt die AWS kontobasierte Endpunkt-ID an, die für Anrufe an den Support verwendet werden soll. AWS-Services
```
aws_account_id =
```
+ `account\$1id\$1endpoint\$1mode`- Gibt an, ob der AWS kontobasierte Endpunkt IDs für Anrufe an den Support verwendet werden soll. AWS-Services Mögliche Einstellungen sind `preferred`, `disabled` oder `required`. Der Standardwert ist preferred.
```
account_id_endpoint_mode = preferred
```
Kontobasierte Endpunkte sorgen für hohe Leistung und Skalierbarkeit, indem sie mithilfe Ihrer AWS Konto-ID die Weiterleitung von AWS-Service Anfragen für Dienste, die diese Funktion unterstützen, optimieren. Wenn Sie einen Anbieter für Anmeldeinformationen und einen Dienst verwenden, der kontobasierte Endpunkte unterstützt, erstellt und verwendet dieser AWS CLI automatisch einen kontobasierten Endpunkt anstelle eines regionalen Endpunkts.
Kontobasierte Endpunkte verwenden das folgende Format, wobei es durch Ihre Konto-ID und durch Ihre ersetzt `` wird: AWS `` AWS-Region
```
https://.myservice..amazonaws.com
```
Standardmäßig ist der AWS CLI kontobasierte Endpunktmodus auf eingestellt. `preferred`
## Priorität der Endpunktkonfiguration und der Einstellungen
Die Einstellungen für die Endpunktkonfiguration befinden sich an mehreren Stellen, z. B. in den System- oder Benutzerumgebungsvariablen, in lokalen AWS Konfigurationsdateien, oder sie werden explizit in der Befehlszeile als Parameter deklariert. Die Einstellungen für die AWS CLI Endpunktkonfiguration haben in der folgenden Reihenfolge Vorrang:
1. Die Befehlszeilenoption `--endpoint-url`
1. Bei aktivierter Option die globale Endpunkt-Umgebungsvariable `AWS\$1IGNORE\$1CONFIGURED\$1ENDPOINT\$1URLS` oder die Profileinstellung `ignore\$1configure\$1endpoint\$1urls` zum Ignorieren von benutzerdefinierten Endpunkten
1. Der Wert, der von einer servicespezifischen Umgebungsvariablen `AWS\$1ENDPOINT\$1URL\$1` bereitgestellt wird, z. B. `AWS_ENDPOINT_URL_DYNAMODB`
1. Die von den `AWS\$1USE\$1DUALSTACK\$1ENDPOINT`-, `AWS\$1USE\$1FIPS\$1ENDPOINT`- und `AWS\$1ENDPOINT\$1URL`-Umgebungsvariablen bereitgestellten Werte.
1. Die `AWS\$1ACCOUNT\$1ID\$1ENDPOINT\$1MODE`-Umgebungsvariable ist auf `required` oder `preferred` festgelegt, wobei die Konto-ID in der `AWS\$1ACCOUNT\$1ID`-Umgebungsvariable oder der `aws\$1account\$1id`-Einstellung verwendet wird.
1. Der servicespezifische Endpunktwert, der durch die Einstellung `endpoint\$1url` in einem `services`-Abschnitt der freigegebenen `config`-Datei bereitgestellt wird
1. Der Wert, der durch die Einstellung `endpoint\$1url` in einem `profile` der freigegebenen `config`-Datei bereitgestellt wird
1. `use\$1dualstack\$1endpoint`-, `use\$1fips\$1endpoint`- und `endpoint\$1url`-Einstellungen.
1. Die `account\$1id\$1endpoint\$1mode`-Einstellung ist auf `required` oder `preferred` festgelegt, wobei die Konto-ID in der `AWS\$1ACCOUNT\$1ID`-Umgebungsvariable oder der `aws\$1account\$1id`-Einstellung verwendet wird.
1. Jede Standard-Endpunkt-URL für den jeweiligen Endpunkt AWS-Service wird zuletzt verwendet. Eine Liste der Standard-Service-Endpunkte, die in den einzelnen Regionen verfügbar sind, finden Sie unter [AWS -Regionen und -Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html) im *Allgemeine Amazon Web Services-Referenz*.