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.
# Erste Schritte mit AWS CLI
In diesem Kapitel finden Sie eine Übersicht über die ersten Schritte mit Version 2 der AWS Command Line Interface (AWS CLI) und Links zu den entsprechenden Anleitungen.
1. **[Erfüllen aller Voraussetzungen](getting-started-prereqs.md)** – Um mit der AWS CLI auf AWS-Services zugreifen zu können, benötigen Sie mindestens ein AWS-Konto und IAM-Anmeldeinformationen. Für die Sicherheit Ihres AWS-Kontos wird empfohlen, nicht die Anmeldeinformationen für Ihr Stammkonto zu verwenden. Sie sollten einen IAM-Benutzer mit der geringsten Berechtigung erstellen, um Anmeldeinformationen für die Aufgaben bereitzustellen, die Sie in AWS ausführen werden.
1. Verwenden Sie eine der folgenden Methoden, um die AWS CLI zu installieren oder Zugriff darauf zu erhalten:
+ **(Empfohlen)** [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md).
+ [Installation früherer Versionen der AWS CLI Version 2](getting-started-version.md). Die Installation einer bestimmten Version wird hauptsächlich verwendet, wenn Ihr Team seine Tools auf eine bestimmte Version ausrichtet.
+ [AWS CLI Aus dem Quellcode erstellen und installieren](getting-started-source-install.md). Das Erstellen der AWS CLI aus einer GitHub-Quelle ist eine ausführlichere Methode, die hauptsächlich von Kunden verwendet wird, die auf Plattformen arbeiten, die wir nicht direkt mit unseren vorgefertigten Installationsprogrammen unterstützen.
+ [Ausführen der offiziellen Amazon ECR Public- oder Docker-Images für AWS CLI](getting-started-docker.md).
+ Greifen Sie auf AWS CLI Version 2 in der AWS-Konsole von Ihrem Browser aus mit AWS CloudShell aus zu. Weitere Informationen finden Sie im [AWS CloudShell-Benutzerhandbuch](https://docs.aws.amazon.com/cloudshell/latest/userguide/).
1. [Nachdem Sie Zugriff auf die AWS CLI haben, konfigurieren Sie Ihre AWS CLI für die erste Verwendung mit Ihren IAM-Anmeldeinformationen](getting-started-quickstart.md).
**Beheben von Installationsprogramm- oder Konfigurationsfehlern**
Wenn nach der Installation, Deinstallation oder Konfiguration der AWS CLI Fehler auftreten, finden Sie unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) Informationen zur Fehlerbehebung.
**Topics**
+ [Voraussetzungen für die Verwendung der AWS CLI Version 2](getting-started-prereqs.md)
+ [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md)
+ [Installation früherer Versionen der AWS CLI Version 2](getting-started-version.md)
+ [AWS CLI Aus dem Quellcode erstellen und installieren](getting-started-source-install.md)
+ [Ausführen der offiziellen Amazon ECR Public- oder Docker-Images für AWS CLI](getting-started-docker.md)
+ [Einrichtung der AWS CLI](getting-started-quickstart.md)
# Voraussetzungen für die Verwendung der AWS CLI Version 2
Um mit dem auf AWS Dienste zugreifen zu können AWS CLI, benötigen Sie eine AWS-Konto mit IAM- oder IAM Identity Center-Anmeldeinformationen. Um AWS CLI Befehle ausführen zu können, AWS CLI müssen sie Zugriff auf diese AWS Anmeldeinformationen haben. Um die Sicherheit Ihres AWS Kontos zu erhöhen, empfehlen wir, nur kurzlebige Anmeldeinformationen zu verwenden, wenn Sie Root- oder IAM-Benutzer verwenden. Sie sollten einen Benutzer mit den geringsten Rechten erstellen, um Zugangsdaten für die Aufgaben bereitzustellen, die Sie ausführen werden. AWS Informationen zu bewährten Methoden finden Sie unter [Bewährte Sicherheitsmethoden](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) im IAM-Benutzerhandbuch.
**Topics**
+ [Ein IAM-Konto oder ein administratives IAM-Identity-Center-Konto erstellen](#getting-started-prereqs-iam)
+ [Nächste Schritte](#getting-started-prereqs-next)
## Ein IAM-Konto oder ein administratives IAM-Identity-Center-Konto erstellen
Bevor Sie das konfigurieren können AWS CLI, müssen Sie ein IAM- oder IAM Identity Center-Konto erstellen.
**Optionen zur Kontoerstellung**
| Wählen Sie eine Methode zur Verwaltung Ihrer Anmeldeinformationen | Bis | Wie erstelle ich ein Konto | Wie konfiguriert man den programmatischen Zugriff auf das Konto |
| --- | --- | --- | --- |
| AWS Anmeldeinformationen für die Managementkonsole | Verwenden Sie kurzfristige Anmeldeinformationen, die dem Root-Benutzer entsprechen, der bei der ersten Kontoeinrichtung erstellt wurde, einem IAM-Benutzer oder einer föderierten Identität von Ihrem Identitätsanbieter. | Öffnen Sie die [https://portal.aws.amazon.com/billing/Registrierung](https://portal.aws.amazon.com/billing/signup) und folgen Sie den Online-Anweisungen. | Es sind keine zusätzlichen Schritte erforderlich. Informationen zur Anmeldung AWS CLI mit Ihrem AWS Konto finden Sie unter [Melden Sie sich mit Konsolenanmeldedaten für die AWS lokale Entwicklung an](cli-configure-sign-in.md) |
| IAM Identity Center | Verwenden Sie kurzfristige Anmeldeinformationen, um auf AWS Dienste zuzugreifen. | Folgen Sie den Anweisungen unter Erste Schritte im AWS IAM Identity Center-Benutzerhandbuch. | Konfigurieren Sie den programmatischen Zugriff, indem Sie die Konfiguration für die Verwendung im AWS IAM Identity Center-Benutzerhandbuch konfigurieren. |
| AWS Identitäts- und Zugriffsverwaltung(Nicht empfohlen) | Verwenden Sie langfristige Anmeldeinformationen, um auf Dienste zuzugreifen AWS . | Folgen Sie den Anweisungen unter Erstellen eines Notfallzugriffs im IAM-Benutzerhandbuch. | Konfigurieren Sie den programmatischen Zugriff unter Zugriffsschlüssel für Benutzer verwalten im IAM-Benutzerhandbuch. |
## Nächste Schritte
Nachdem Sie ein AWS-Konto und Ihre IAM-Anmeldeinformationen erstellt haben, können AWS CLI Sie Folgendes tun, um das zu verwenden:
+ [Installieren Sie die neueste Version](getting-started-install.md) der AWS CLI Version 2 auf Ihrem Computer.
+ [Installieren Sie eine frühere Version](getting-started-version.md) der AWS CLI Version 2 auf Ihrem Computer.
+ Greifen Sie [mit einem Docker-Image](getting-started-docker.md) von Ihrem Computer aus auf AWS CLI Version 2 zu.
+ Greifen Sie von Ihrem Browser aus auf AWS CLI Version 2 in der AWS Konsole zu, indem Sie AWS CloudShell Weitere Informationen finden Sie im [AWS CloudShell -Benutzerhandbuch](https://docs.aws.amazon.com/cloudshell/latest/userguide/).
# Installation oder Aktualisierung auf die neueste Version von AWS CLI
In diesem Thema wird beschrieben, wie Sie die neueste Version von AWS Command Line Interface (AWS CLI) auf unterstützten Betriebssystemen installieren oder aktualisieren. Informationen zu den neuesten Versionen von AWS CLI finden Sie im [Changelog für AWS CLI Version 2.](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) GitHub
Informationen zur Installation einer früheren Version von finden Sie AWS CLI unter[Installation früherer Versionen der AWS CLI Version 2](getting-started-version.md). Informationen zum Deinstallieren finden Sie unter [Deinstallation der AWS CLI Version 2](uninstall.md).
**Wichtig**
AWS CLI Die Versionen 1 und 2 verwenden denselben `aws` Befehlsnamen. Wenn Sie AWS CLI Version 1 bereits installiert haben, finden Sie weitere Informationen unter[Migrationsleitfaden für die AWS CLI Version 2](cliv2-migration.md).
**Topics**
+ [AWS CLI Anweisungen zur Installation und Aktualisierung](#getting-started-install-instructions)
+ [Behebung von AWS CLI Installations- und Deinstallationsfehlern](#install-tshoot)
+ [Nächste Schritte](#install-next-steps)
## AWS CLI Anweisungen zur Installation und Aktualisierung
Die Installationsanweisungen finden Sie im Abschnitt für Ihr Betriebssystem.
### Linux
#### Voraussetzungen für die Installation und Aktualisierung
+ Sie müssen das heruntergeladene Paket extrahieren oder „entpacken“ können. Wenn Ihr Betriebssystem nicht über den integrierten `unzip`-Befehl verfügt, verwenden Sie ein Äquivalent.
+ Die AWS CLI Verwendungen `glibc``groff`, und`less`. Diese sind standardmäßig in den meisten großen Linux-Distributionen enthalten.
+ Wir unterstützen die AWS CLI 64-Bit-Versionen neuerer Distributionen von CentOS, Fedora, Ubuntu, Amazon Linux 1, Amazon Linux 2, Amazon Linux 2023 und Linux ARM.
+ Da AWS keine anderen Repositorys von Drittanbietern verwaltet werden`snap`, können wir nicht garantieren, dass sie die neueste Version von enthalten. AWS CLI
#### Installiere oder aktualisiere das AWS CLI
**Warnung**
Wenn Sie zum ersten Mal auf Amazon Linux aktualisieren, müssen Sie die vorinstallierte Version mit dem folgenden Befehl deinstallieren AWS CLI, um die neueste `yum` Version von zu installieren:
```
$ sudo yum remove awscli
```
Nachdem die `yum` Installation von entfernt wurde, folgen Sie den nachstehenden Installationsanweisungen für Linux. AWS CLI
Sie können das AWS CLI mit einer der folgenden Methoden installieren:
+ **Das Befehlszeilen-Installationsprogramm** ist eine gute Option für die Versionskontrolle, da Sie die zu installierende Version angeben können. Diese Option wird nicht automatisch aktualisiert, und Sie müssen bei jedem Update ein neues Installationsprogramm herunterladen, um die frühere Version zu überschreiben.
+ **Das offiziell unterstützte `snap` Paket** ist eine gute Option, um immer die neueste Version der AWS CLI As-Snap-Pakete automatisch aktualisieren zu lassen. Es gibt keine integrierte Unterstützung für die Auswahl von Nebenversionen von AWS CLI und ist daher keine optimale Installationsmethode, wenn Ihr Team Versionen anheften muss.
------
#### [ Command line installer - Linux x86 (64-bit) ]
Um Ihre aktuelle Installation von zu aktualisieren AWS CLI, laden Sie bei jedem Update ein neues Installationsprogramm herunter, um frühere Versionen zu überschreiben. Folgen Sie diesen Schritten von der Befehlszeile aus, um das unter Linux AWS CLI zu installieren.
Im Folgenden finden Sie schnelle Installationsschritte in einer einzigen Gruppe zum Kopieren und Einfügen, die eine einfache Installation ermöglichen. Weitere Anleitungen finden Sie in den folgenden Schritten.
**Anmerkung**
**(Optional)** Mit dem folgenden Befehlsblock wird der heruntergeladen und installiert, AWS CLI ohne zuvor die Integrität Ihres Downloads zu überprüfen. Gehen Sie wie folgt vor, um die Integrität Ihres Downloads zu überprüfen.
Führen Sie **zur Installation** der AWS CLI die folgenden Befehle aus.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
Fügen Sie **zur Aktualisierung Ihrer aktuellen Installation** der AWS CLI Ihre vorhandenen Symlink- und Installationsinformationen hinzu, um den `install`-Befehl mit den Parametern `--bin-dir`, `--install-dir` und `--update` zu konstruieren. Der folgende Befehlsblock verwendet einen Beispiel-Symlink mit einem Beispielverzeichnis */usr/local/bin* für das Installationsprogramm von*/usr/local/aws-cli*, um das AWS CLI lokal für den aktuellen Benutzer zu installieren.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
**Geführte Installationsschritte**
1. Laden Sie die Installationsdatei auf eine der folgenden Arten herunter:
+ **Mit dem Befehl`curl`** – Die `-o`-Option gibt den Namen der Datei an, in die das heruntergeladene Paket geschrieben wird. Aufgrund der Optionen im folgenden Beispielbefehl wird die heruntergeladene Datei in das aktuelle Verzeichnis mit dem lokalen Namen `awscliv2.zip` geschrieben.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
```
+ **Download über die URL** – Verwenden Sie eine der folgenden URLs, um das Installationsprogramm mit Ihrem Browser herunterzuladen: [https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip](https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip)
1. **(Optional) Überprüfen der Integrität Ihrer heruntergeladenen Zip-Datei**
Wenn Sie sich `.zip` in den obigen Schritten dafür entschieden haben, das AWS CLI Installationspaket manuell herunterzuladen, können Sie die folgenden Schritte ausführen, um die Signaturen mithilfe des `GnuPG` Tools zu überprüfen.
Die `.zip` Dateien des AWS CLI Installationspakets sind mithilfe von PGP-Signaturen kryptografisch signiert. Wenn die Dateien beschädigt oder verändert wurden, schlägt diese Verifizierung fehl und Sie sollten nicht mit der Installation fortfahren.
1. Laden Sie den `gpg`-Befehl herunter und installieren Sie diesen mit Ihrem Paket-Manager. Weitere Informationen zu `GnuPG` finden Sie auf der [GnuPG-Website](https://www.gnupg.org/).
1. Um die öffentliche Schlüsseldatei zu erstellen, müssen Sie eine Textdatei erstellen und den folgenden Text einfügen.
```
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBF2Cr7UBEADJZHcgusOJl7ENSyumXh85z0TRV0xJorM2B/JL0kHOyigQluUG
ZMLhENaG0bYatdrKP+3H91lvK050pXwnO/R7fB/FSTouki4ciIx5OuLlnJZIxSzx
PqGl0mkxImLNbGWoi6Lto0LYxqHN2iQtzlwTVmq9733zd3XfcXrZ3+LblHAgEt5G
TfNxEKJ8soPLyWmwDH6HWCnjZ/aIQRBTIQ05uVeEoYxSh6wOai7ss/KveoSNBbYz
gbdzoqI2Y8cgH2nbfgp3DSasaLZEdCSsIsK1u05CinE7k2qZ7KgKAUIcT/cR/grk
C6VwsnDU0OUCideXcQ8WeHutqvgZH1JgKDbznoIzeQHJD238GEu+eKhRHcz8/jeG
94zkcgJOz3KbZGYMiTh277Fvj9zzvZsbMBCedV1BTg3TqgvdX4bdkhf5cH+7NtWO
lrFj6UwAsGukBTAOxC0l/dnSmZhJ7Z1KmEWilro/gOrjtOxqRQutlIqG22TaqoPG
fYVN+en3Zwbt97kcgZDwqbuykNt64oZWc4XKCa3mprEGC3IbJTBFqglXmZ7l9ywG
EEUJYOlb2XrSuPWml39beWdKM8kzr1OjnlOm6+lpTRCBfo0wa9F8YZRhHPAkwKkX
XDeOGpWRj4ohOx0d2GWkyV5xyN14p2tQOCdOODmz80yUTgRpPVQUtOEhXQARAQAB
tCFBV1MgQ0xJIFRlYW0gPGF3cy1jbGlAYW1hem9uLmNvbT6JAlQEEwEIAD4CGwMF
CwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQT7Xbd/1cEYuAURraimMQrMRnJHXAUC
aGveYQUJDMpiLAAKCRCmMQrMRnJHXKBYD/9Ab0qQdGiO5hObchG8xh8Rpb4Mjyf6
0JrVo6m8GNjNj6BHkSc8fuTQJ/FaEhaQxj3pjZ3GXPrXjIIVChmICLlFuRXYzrXc
Pw0lniybypsZEVai5kO0tCNBCCFuMN9RsmmRG8mf7lC4FSTbUDmxG/QlYK+0IV/l
uJkzxWa+rySkdpm0JdqumjegNRgObdXHAQDWlubWQHWyZyIQ2B4U7AxqSpcdJp6I
S4Zds4wVLd1WE5pquYQ8vS2cNlDm4QNg8wTj58e3lKN47hXHMIb6CHxRnb947oJa
pg189LLPR5koh+EorNkA1wu5mAJtJvy5YMsppy2y/kIjp3lyY6AmPT1posgGk70Z
CmToEZ5rbd7ARExtlh76A0cabMDFlEHDIK8RNUOSRr7L64+KxOUegKBfQHb9dADY
qqiKqpCbKgvtWlds909Ms74JBgr2KwZCSY1HaOxnIr4CY43QRqAq5YHOay/mU+6w
hhmdF18vpyK0vfkvvGresWtSXbag7Hkt3XjaEw76BzxQH21EBDqU8WJVjHgU6ru+
DJTs+SxgJbaT3hb/vyjlw0lK+hFfhWKRwgOXH8vqducF95NRSUxtS4fpqxWVaw3Q
V2OWSjbne99A5EPEySzryFTKbMGwaTlAwMCwYevt4YT6eb7NmFhTx0Fis4TalUs+
j+c7Kg92pDx2uQ==
=OBAt
-----END PGP PUBLIC KEY BLOCK-----
```
Als Referenz finden Sie im Folgenden die Details des öffentlichen Schlüssels.
```
Key ID: A6310ACC4672475C
Type: RSA
Size: 4096/4096
Created: 2019-09-18
Expires: 2026-07-07
User ID: AWS CLI Team
Key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
1. Importieren Sie den AWS CLI öffentlichen Schlüssel mit dem folgenden Befehl und ersetzen Sie ihn durch den Dateinamen des öffentlichen *public-key-file-name* Schlüssels, den Sie erstellt haben.
```
$ gpg --import public-key-file-name
gpg: /home/username/.gnupg/trustdb.gpg: trustdb created
gpg: key A6310ACC4672475C: public key "AWS CLI Team " imported
gpg: Total number processed: 1
gpg: imported: 1
```
1. Laden Sie die AWS CLI Signaturdatei für das Paket herunter, das Sie heruntergeladen haben. Sie hat denselben Pfad und denselben Namen wie die `.zip`-Datei, der sie entspricht, hat aber die Erweiterung `.sig`. In den folgenden Beispielen speichern wir sie im aktuellen Verzeichnis als Datei namens `awscliv2.sig`.
Verwenden Sie **für die AWS CLI neueste Version von** den folgenden Befehlsblock:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip.sig
```
1. Überprüfen Sie die Signatur und übergeben Sie sowohl den heruntergeladenen `.sig`- als auch den `.zip`-Dateinamen als Parameter an den `gpg`-Befehl.
```
$ gpg --verify awscliv2.sig awscliv2.zip
```
Die Ausgabe sollte in etwa folgendermaßen aussehen:
```
gpg: Signature made Mon Nov 4 19:00:01 2019 PST
gpg: using RSA key FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
gpg: Good signature from "AWS CLI Team " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
**Wichtig**
Die Warnung in der Ausgabe wird erwartet und ist kein Hinweis auf ein Problem. Das liegt daran, dass zwischen Ihrem persönlichen PGP-Schlüssel (falls Sie einen haben) und dem AWS CLI PGP-Schlüssel keine Vertrauenskette besteht. Weitere Informationen finden Sie unter [Web of trust](https://en.wikipedia.org/wiki/Web_of_trust) (Netz des Vertrauens).
1. Entpacken Sie das Installationsprogramm. Wenn Ihre Linux-Distribution keinen integrierten `unzip`-Befehl aufweist, verwenden Sie ein Äquivalent, um es zu entpacken. Der folgende Beispielbefehl entpackt das Paket und erstellt ein Verzeichnis mit dem Namen `aws` im aktuellen Verzeichnis.
```
$ unzip awscliv2.zip
```
**Anmerkung**
Bei einem Update von einer früheren Version fordert der `unzip`-Befehl zum Überschreiben vorhandener Dateien auf. Um diese Aufforderungen zu überspringen, beispielsweise bei der Skriptautomatisierung, verwenden Sie die Aktualisierungsmarkierung `-u` für `unzip`. Diese Markierung sorgt dafür, dass vorhandene Dateien automatisch aktualisiert und bei Bedarf neue erstellt werden.
```
$ unzip -u awscliv2.zip
```
1. Führen Sie das Installationsprogramm aus. Der Installationsbefehl verwendet eine Datei namens `install` im neu entpackten `aws`-Verzeichnis. Standardmäßig werden alle Dateien unter `/usr/local/aws-cli` installiert und ein symbolischer Link wird in `/usr/local/bin` erstellt. Der Befehl enthält `sudo`, um diesen Verzeichnissen Schreibberechtigungen zu erteilen.
```
$ sudo ./aws/install
```
Sie können ohne `sudo` installieren, wenn Sie Ordner angeben, für die Sie bereits über Schreibberechtigungen verfügen. Verwenden Sie die folgenden Anweisungen für den `install`-Befehl, um den Installationsort anzugeben:
+ Stellen Sie sicher, dass die Pfade, die Sie zu den Parametern `-i` und `-b` angeben, keine Volume- oder Verzeichnisnamen mit Leerstellen oder Leerräumen enthalten. Wenn ein Leerzeichen vorhanden ist, schlägt die Installation fehl.
+ `--install-dir` oder `-i` – Diese Option gibt das Verzeichnis an, in den alle Dateien kopiert werden sollen.
Der Standardwert ist `/usr/local/aws-cli`.
+ `--bin-dir` oder `-b` – Diese Option gibt an, dass das `aws`-Hauptprogramm im Installationsordner mit der Datei `aws` im angegebenen Pfad symbolisch verknüpft ist. Sie müssen über Schreibberechtigungen für das angegebene Verzeichnis verfügen. Wenn Sie einen Symlink zu einem Verzeichnis erstellen, das sich bereits im Pfad befindet, ist es nicht notwendig, das Installationsverzeichnis der `$PATH`-Variablen des Benutzers hinzuzufügen.
Der Standardwert ist `/usr/local/bin`.
```
$ ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
```
**Anmerkung**
Um Ihre aktuelle Installation von zu aktualisieren AWS CLI, fügen Sie Ihren vorhandenen Symlink und Ihre Installationsinformationen hinzu, um den `install` Befehl mit dem Parameter zu erstellen. `--update`
```
$ sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
Gehen Sie wie folgt vor, um den vorhandenen Symlink und das Installationsverzeichnis zu suchen:
Verwenden Sie den `which`-Befehl, um Ihren Symlink zu finden. Dadurch erhalten Sie den Pfad, der mit dem `--bin-dir`-Parameter verwendet werden soll.
```
$ which aws
/usr/local/bin/aws
```
Verwenden Sie den `ls`-Befehl, um das Verzeichnis zu finden, auf das Ihr Symlink verweist. Dadurch erhalten Sie den Pfad, der mit dem `--install-dir`-Parameter verwendet werden soll.
```
$ ls -l /usr/local/bin/aws
lrwxrwxrwx 1 ec2-user ec2-user 49 Oct 22 09:49 /usr/local/bin/aws -> /usr/local/aws-cli/v2/current/bin/aws
```
1. Bestätigen Sie die Installation mit dem folgenden Befehl.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Wenn der `aws`-Befehl nicht gefunden wird, müssen Sie möglicherweise Ihr Terminal neu starten oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
------
#### [ Command line - Linux ARM ]
Um Ihre aktuelle Installation von zu aktualisieren AWS CLI, laden Sie bei jedem Update ein neues Installationsprogramm herunter, um frühere Versionen zu überschreiben. Folgen Sie diesen Schritten von der Befehlszeile aus, um das unter Linux AWS CLI zu installieren.
Im Folgenden finden Sie schnelle Installationsschritte in einer einzigen Gruppe zum Kopieren und Einfügen, die eine einfache Installation ermöglichen. Weitere Anleitungen finden Sie in den folgenden Schritten.
**Anmerkung**
**(Optional)** Mit dem folgenden Befehlsblock wird der heruntergeladen und installiert, AWS CLI ohne zuvor die Integrität Ihres Downloads zu überprüfen. Gehen Sie wie folgt vor, um die Integrität Ihres Downloads zu überprüfen.
Führen **Sie** die folgenden Befehle aus AWS CLI, um das zu installieren.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
Fügen Sie **zur Aktualisierung Ihrer aktuellen Installation** der AWS CLI Ihre vorhandenen Symlink- und Installationsinformationen hinzu, um den `install`-Befehl mit den Parametern `--bin-dir`, `--install-dir` und `--update` zu konstruieren. Der folgende Befehlsblock verwendet einen Beispiel-Symlink von */usr/local/bin* und ein Beispiel für den Speicherort des Installationsprogramms von*/usr/local/aws-cli*.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
**Geführte Installationsschritte**
1. Laden Sie die Installationsdatei auf eine der folgenden Arten herunter:
+ **Mit dem Befehl`curl`** – Die `-o`-Option gibt den Namen der Datei an, in die das heruntergeladene Paket geschrieben wird. Aufgrund der Optionen im folgenden Beispielbefehl wird die heruntergeladene Datei in das aktuelle Verzeichnis mit dem lokalen Namen `awscliv2.zip` geschrieben.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
```
+ **Download über die URL** – Verwenden Sie eine der folgenden URLs, um das Installationsprogramm mit Ihrem Browser herunterzuladen: [https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip](https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip)
1. **(Optional) Überprüfen der Integrität Ihrer heruntergeladenen Zip-Datei**
Wenn Sie sich `.zip` in den obigen Schritten dafür entschieden haben, das AWS CLI Installationspaket manuell herunterzuladen, können Sie die folgenden Schritte ausführen, um die Signaturen mithilfe des `GnuPG` Tools zu überprüfen.
Die `.zip` Dateien des AWS CLI Installationspakets sind mithilfe von PGP-Signaturen kryptografisch signiert. Wenn die Dateien beschädigt oder verändert wurden, schlägt diese Verifizierung fehl und Sie sollten nicht mit der Installation fortfahren.
1. Laden Sie den `gpg`-Befehl herunter und installieren Sie diesen mit Ihrem Paket-Manager. Weitere Informationen zu `GnuPG` finden Sie auf der [GnuPG-Website](https://www.gnupg.org/).
1. Um die öffentliche Schlüsseldatei zu erstellen, müssen Sie eine Textdatei erstellen und den folgenden Text einfügen.
```
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBF2Cr7UBEADJZHcgusOJl7ENSyumXh85z0TRV0xJorM2B/JL0kHOyigQluUG
ZMLhENaG0bYatdrKP+3H91lvK050pXwnO/R7fB/FSTouki4ciIx5OuLlnJZIxSzx
PqGl0mkxImLNbGWoi6Lto0LYxqHN2iQtzlwTVmq9733zd3XfcXrZ3+LblHAgEt5G
TfNxEKJ8soPLyWmwDH6HWCnjZ/aIQRBTIQ05uVeEoYxSh6wOai7ss/KveoSNBbYz
gbdzoqI2Y8cgH2nbfgp3DSasaLZEdCSsIsK1u05CinE7k2qZ7KgKAUIcT/cR/grk
C6VwsnDU0OUCideXcQ8WeHutqvgZH1JgKDbznoIzeQHJD238GEu+eKhRHcz8/jeG
94zkcgJOz3KbZGYMiTh277Fvj9zzvZsbMBCedV1BTg3TqgvdX4bdkhf5cH+7NtWO
lrFj6UwAsGukBTAOxC0l/dnSmZhJ7Z1KmEWilro/gOrjtOxqRQutlIqG22TaqoPG
fYVN+en3Zwbt97kcgZDwqbuykNt64oZWc4XKCa3mprEGC3IbJTBFqglXmZ7l9ywG
EEUJYOlb2XrSuPWml39beWdKM8kzr1OjnlOm6+lpTRCBfo0wa9F8YZRhHPAkwKkX
XDeOGpWRj4ohOx0d2GWkyV5xyN14p2tQOCdOODmz80yUTgRpPVQUtOEhXQARAQAB
tCFBV1MgQ0xJIFRlYW0gPGF3cy1jbGlAYW1hem9uLmNvbT6JAlQEEwEIAD4CGwMF
CwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQT7Xbd/1cEYuAURraimMQrMRnJHXAUC
aGveYQUJDMpiLAAKCRCmMQrMRnJHXKBYD/9Ab0qQdGiO5hObchG8xh8Rpb4Mjyf6
0JrVo6m8GNjNj6BHkSc8fuTQJ/FaEhaQxj3pjZ3GXPrXjIIVChmICLlFuRXYzrXc
Pw0lniybypsZEVai5kO0tCNBCCFuMN9RsmmRG8mf7lC4FSTbUDmxG/QlYK+0IV/l
uJkzxWa+rySkdpm0JdqumjegNRgObdXHAQDWlubWQHWyZyIQ2B4U7AxqSpcdJp6I
S4Zds4wVLd1WE5pquYQ8vS2cNlDm4QNg8wTj58e3lKN47hXHMIb6CHxRnb947oJa
pg189LLPR5koh+EorNkA1wu5mAJtJvy5YMsppy2y/kIjp3lyY6AmPT1posgGk70Z
CmToEZ5rbd7ARExtlh76A0cabMDFlEHDIK8RNUOSRr7L64+KxOUegKBfQHb9dADY
qqiKqpCbKgvtWlds909Ms74JBgr2KwZCSY1HaOxnIr4CY43QRqAq5YHOay/mU+6w
hhmdF18vpyK0vfkvvGresWtSXbag7Hkt3XjaEw76BzxQH21EBDqU8WJVjHgU6ru+
DJTs+SxgJbaT3hb/vyjlw0lK+hFfhWKRwgOXH8vqducF95NRSUxtS4fpqxWVaw3Q
V2OWSjbne99A5EPEySzryFTKbMGwaTlAwMCwYevt4YT6eb7NmFhTx0Fis4TalUs+
j+c7Kg92pDx2uQ==
=OBAt
-----END PGP PUBLIC KEY BLOCK-----
```
Als Referenz finden Sie im Folgenden die Details des öffentlichen Schlüssels.
```
Key ID: A6310ACC4672475C
Type: RSA
Size: 4096/4096
Created: 2019-09-18
Expires: 2026-07-07
User ID: AWS CLI Team
Key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
1. Importieren Sie den AWS CLI öffentlichen Schlüssel mit dem folgenden Befehl und ersetzen Sie ihn durch den Dateinamen des öffentlichen *public-key-file-name* Schlüssels, den Sie erstellt haben.
```
$ gpg --import public-key-file-name
gpg: /home/username/.gnupg/trustdb.gpg: trustdb created
gpg: key A6310ACC4672475C: public key "AWS CLI Team " imported
gpg: Total number processed: 1
gpg: imported: 1
```
1. Laden Sie die AWS CLI Signaturdatei für das Paket herunter, das Sie heruntergeladen haben. Sie hat denselben Pfad und denselben Namen wie die `.zip`-Datei, der sie entspricht, hat aber die Erweiterung `.sig`. In den folgenden Beispielen speichern wir sie im aktuellen Verzeichnis als Datei namens `awscliv2.sig`.
Verwenden Sie **für die AWS CLI neueste Version von** den folgenden Befehlsblock:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip.sig
```
1. Überprüfen Sie die Signatur und übergeben Sie sowohl den heruntergeladenen `.sig`- als auch den `.zip`-Dateinamen als Parameter an den `gpg`-Befehl.
```
$ gpg --verify awscliv2.sig awscliv2.zip
```
Die Ausgabe sollte in etwa folgendermaßen aussehen:
```
gpg: Signature made Mon Nov 4 19:00:01 2019 PST
gpg: using RSA key FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
gpg: Good signature from "AWS CLI Team " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
**Wichtig**
Die Warnung in der Ausgabe wird erwartet und ist kein Hinweis auf ein Problem. Das liegt daran, dass zwischen Ihrem persönlichen PGP-Schlüssel (falls Sie einen haben) und dem AWS CLI PGP-Schlüssel keine Vertrauenskette besteht. Weitere Informationen finden Sie unter [Web of trust](https://en.wikipedia.org/wiki/Web_of_trust) (Netz des Vertrauens).
1. Entpacken Sie das Installationsprogramm. Wenn Ihre Linux-Distribution keinen integrierten `unzip`-Befehl aufweist, verwenden Sie ein Äquivalent, um es zu entpacken. Der folgende Beispielbefehl entpackt das Paket und erstellt ein Verzeichnis mit dem Namen `aws` im aktuellen Verzeichnis.
```
$ unzip awscliv2.zip
```
**Anmerkung**
Bei einem Update von einer früheren Version fordert der `unzip`-Befehl zum Überschreiben vorhandener Dateien auf. Um diese Aufforderungen zu überspringen, beispielsweise bei der Skriptautomatisierung, verwenden Sie die Aktualisierungsmarkierung `-u` für `unzip`. Diese Markierung sorgt dafür, dass vorhandene Dateien automatisch aktualisiert und bei Bedarf neue erstellt werden.
```
$ unzip -u awscliv2.zip
```
1. Führen Sie das Installationsprogramm aus. Der Installationsbefehl verwendet eine Datei namens `install` im neu entpackten `aws`-Verzeichnis. Standardmäßig werden alle Dateien unter `/usr/local/aws-cli` installiert und ein symbolischer Link wird in `/usr/local/bin` erstellt. Der Befehl enthält `sudo`, um diesen Verzeichnissen Schreibberechtigungen zu erteilen.
```
$ sudo ./aws/install
```
Sie können ohne `sudo` installieren, wenn Sie Ordner angeben, für die Sie bereits über Schreibberechtigungen verfügen. Verwenden Sie die folgenden Anweisungen für den `install`-Befehl, um den Installationsort anzugeben:
+ Stellen Sie sicher, dass die Pfade, die Sie zu den Parametern `-i` und `-b` angeben, keine Volume- oder Verzeichnisnamen mit Leerstellen oder Leerräumen enthalten. Wenn ein Leerzeichen vorhanden ist, schlägt die Installation fehl.
+ `--install-dir` oder `-i` – Diese Option gibt das Verzeichnis an, in den alle Dateien kopiert werden sollen.
Der Standardwert ist `/usr/local/aws-cli`.
+ `--bin-dir` oder `-b` – Diese Option gibt an, dass das `aws`-Hauptprogramm im Installationsordner mit der Datei `aws` im angegebenen Pfad symbolisch verknüpft ist. Sie müssen über Schreibberechtigungen für das angegebene Verzeichnis verfügen. Wenn Sie einen Symlink zu einem Verzeichnis erstellen, das sich bereits im Pfad befindet, ist es nicht notwendig, das Installationsverzeichnis der `$PATH`-Variablen des Benutzers hinzuzufügen.
Der Standardwert ist `/usr/local/bin`.
```
$ ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
```
**Anmerkung**
Um Ihre aktuelle Installation von zu aktualisieren AWS CLI, fügen Sie Ihren vorhandenen Symlink und Ihre Installationsinformationen hinzu, um den `install` Befehl mit dem Parameter zu erstellen. `--update`
```
$ sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
Gehen Sie wie folgt vor, um den vorhandenen Symlink und das Installationsverzeichnis zu suchen:
Verwenden Sie den `which`-Befehl, um Ihren Symlink zu finden. Dadurch erhalten Sie den Pfad, der mit dem `--bin-dir`-Parameter verwendet werden soll.
```
$ which aws
/usr/local/bin/aws
```
Verwenden Sie den `ls`-Befehl, um das Verzeichnis zu finden, auf das Ihr Symlink verweist. Dadurch erhalten Sie den Pfad, der mit dem `--install-dir`-Parameter verwendet werden soll.
```
$ ls -l /usr/local/bin/aws
lrwxrwxrwx 1 ec2-user ec2-user 49 Oct 22 09:49 /usr/local/bin/aws -> /usr/local/aws-cli/v2/current/bin/aws
```
1. Bestätigen Sie die Installation mit dem folgenden Befehl.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Wenn der `aws`-Befehl nicht gefunden wird, müssen Sie möglicherweise Ihr Terminal neu starten oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
------
#### [ Snap package ]
Wir bieten eine offiziell AWS unterstützte Version von AWS CLI on `snap` an. Wenn Sie möchten, dass immer die neueste Version von auf Ihrem System AWS CLI installiert ist, bietet Ihnen ein Snap-Paket dies, da es automatisch aktualisiert wird. Es gibt keine integrierte Unterstützung für die Auswahl von Nebenversionen von AWS CLI und ist daher keine optimale Installationsmethode, wenn Ihr Team Versionen anheften muss. Wenn Sie eine bestimmte AWS CLI-Nebenversion installieren möchten, empfehlen wir Ihnen, das Befehlszeilen-Installationsprogramm zu verwenden.
1. Wenn auf Ihrer Linux-Plattform `snap` noch nicht installiert ist, sollten Sie `snap` auf Ihrer Plattform installieren.
1. Informationen zur Installation von `snap` finden Sie unter [Installation des Daemons](https://snapcraft.io/docs/installing-snapd) in der *Snap-Dokumentation*.
1. Möglicherweise müssen Sie Ihr System neu starten, damit Ihre `PATH`-Variablen korrekt aktualisiert werden. Wenn Sie Probleme mit der Installation haben, folgen Sie den Schritten unter [Häufig auftretende Probleme beheben](https://snapcraft.io/docs/fix-common-issues) in der *Snap-Dokumentation*.
1. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob `snap` korrekt installiert ist.
```
$ snap version
```
1. Führen Sie den folgenden `snap install`-Befehl für AWS CLI aus:
```
$ snap install aws-cli --classic
```
Je nach Berechtigungen müssen Sie möglicherweise dem Befehl `sudo` hinzufügen.
```
$ sudo snap install aws-cli --classic
```
**Anmerkung**
Das Snap-Repository für AWS CLI, einschließlich zusätzlicher `snap` Anweisungen, finden Sie auf der [https://snapcraft.io/aws-cli](https://snapcraft.io/aws-cli)Seite der *Canonical Snapcraft-Website*.
1. Stellen Sie sicher, dass das korrekt installiert ist AWS CLI .
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Wenn Sie eine Fehlermeldung erhalten, finden Sie weitere Informationen unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md).
------
### macOS
#### Voraussetzungen für die Installation und Aktualisierung
+ Wir unterstützen die AWS CLI macOS-Versionen 11 und höher. Weitere Informationen finden Sie unter [Aktualisierungen der macOS-Supportrichtlinien für AWS CLI Version 2 im AWS](https://aws.amazon.com/blogs/developer/macos-support-policy-updates-for-the-aws-cli-v2/) *Developer Tools-Blog*.
+ Da AWS keine Repositorys von Drittanbietern verwaltet werden, können wir nicht garantieren, dass sie die neueste Version von enthalten. AWS CLI
**Support-Matrix für macOS-Versionen**
| AWS CLI Version | Unterstützte macOS-Versionen |
| --- | --- |
| 2.21.0 bis aktuell | 11 |
| 2.17.0 bis 2.20.0 | 10.15 |
| 2.0.0 bis 2.16.12 | 10.14 und niedriger |
#### Installiere oder aktualisiere die AWS CLI
Wenn Sie auf die neueste Version aktualisieren, verwenden Sie dieselbe Installationsmethode, die Sie bei der aktuellen Version verwendet haben. Sie können das AWS CLI auf folgende Weise auf macOS installieren.
------
#### [ GUI installer ]
Die folgenden Schritte zeigen, wie Sie die neueste Version AWS CLI von mithilfe der standardmäßigen macOS-Benutzeroberfläche und Ihres Browsers installieren.
1. Laden Sie in Ihrem Browser die macOS-`pkg`-Datei [https://awscli.amazonaws.com/AWSCLIV2.pkg](https://awscli.amazonaws.com/AWSCLIV2.pkg)herunter.
1. Führen Sie die heruntergeladene Datei aus und folgen Sie den Anweisungen auf dem Bildschirm. Sie können wählen, ob Sie das AWS CLI auf folgende Weise installieren möchten:
+ **Für alle Benutzer auf dem Computer (erfordert `sudo`)**
+ Sie können in einem beliebigen Ordner installieren oder den empfohlenen Standardordner `/usr/local/aws-cli` auswählen.
+ Das Installationsprogramm erstellt automatisch einen Symlink unter `/usr/local/bin/aws`, der mit dem Hauptprogramm in dem von Ihnen gewählten Installationsordner verknüpft ist.
+ **Nur für den aktuellen Benutzer (erfordert nicht `sudo`)**
+ Sie können die Installation in jedem beliebigen Ordner vornehmen, für den Sie Schreibberechtigung haben.
+ Aufgrund der standardmäßigen Benutzerberechtigungen müssen Sie nach Abschluss des Installationsprogramms manuell eine Symlink-Datei in Ihrem `$PATH` erstellen, die auf die Programme `aws` und `aws_completer` verweist, indem Sie die folgenden Befehle bei der Eingabeaufforderung verwenden. Der Standardspeicherort für einen Symlink ist`/usr/local/bin/`:
```
$ ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
Wenn Sie keine Schreibberechtigungen für den Ordner haben, müssen Sie möglicherweise `sudo` in Ihrem Befehl verwenden. Im folgenden Beispiel wird `sudo` mit dem Standardspeicherort für einen Symlink in `/usr/local/bin/` verwendet:
```
$ sudo ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ sudo ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
**Anmerkung**
Sie können Debug-Protokolle für die Installation anzeigen, indem Sie **STRG\$1L** an einer beliebigen Stelle im Installationsprogramm drücken. Dadurch wird ein Protokollbereich geöffnet, in dem Sie das Protokoll filtern und speichern können. Die Protokolldatei wird ebenfalls automatisch in `/var/log/install.log` gespeichert.
1. Verwenden Sie die folgenden Befehle, um zu überprüfen, ob die Shell den `aws`-Befehl in Ihrem `$PATH` finden und ausführen kann.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Wenn der `aws`-Befehl nicht gefunden wird, müssen Sie möglicherweise Ihr Terminal neu starten oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
------
#### [ Command line installer - All users ]
Wenn Sie über `sudo`-Berechtigungen verfügen, können Sie die AWS CLI für alle Benutzer auf dem Computer installieren. Wir stellen die Schritte in einer Gruppe bereit, die einfach zu kopieren und einzufügen ist. Lesen Sie die Beschreibungen der einzelnen Zeilen in den folgenden Schritten.
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
$ sudo installer -pkg AWSCLIV2.pkg -target /
```
**Geführte Installationsanleitungen**
1. Laden Sie die Datei mit dem `curl`-Befehl herunter. Die `-o`-Option gibt den Dateinamen an, in den das heruntergeladene Paket geschrieben wird. Im vorherigen Beispiel wird die Datei in `AWSCLIV2.pkg` im aktuellen Verzeichnis geschrieben.
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
```
1. Führen Sie das Standard-macOS-`installer`-Programm aus und geben Sie die heruntergeladene `.pkg`-Datei als Quelle an. Verwenden Sie den `-pkg`-Parameter, um den Namen des zu installierenden Pakets und den `-target /`-Parameter für das Laufwerk, auf dem das Paket installiert werden soll. Die Dateien werden in `/usr/local/aws-cli` installiert, und in `/usr/local/bin` wird automatisch ein Symlink erstellt. Sie müssen dem Befehl `sudo` hinzufügen, um diesen Ordnern Schreibberechtigungen zu erteilen.
```
$ sudo installer -pkg ./AWSCLIV2.pkg -target /
```
Nach Abschluss der Installation werden Debug-Protokolle in `/var/log/install.log` geschrieben.
1. Verwenden Sie die folgenden Befehle, um zu überprüfen, ob die Shell den `aws`-Befehl in Ihrem `$PATH` finden und ausführen kann.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Wenn der `aws`-Befehl nicht gefunden wird, müssen Sie möglicherweise Ihr Terminal neu starten oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
------
#### [ Command line - Current user ]
1. Um anzugeben, in welchem Ordner das installiert AWS CLI ist, müssen Sie eine XML-Datei mit einem beliebigen Dateinamen erstellen. Diese Datei ist eine XML-formatierte Datei, die ähnlich wie im folgenden Beispiel aussieht. Belassen Sie alle Werte wie in der Abbildung, außer dass Sie den Pfad */Users/myusername* in Zeile 9 durch den Pfad zu dem Ordner ersetzen müssen, in dem Sie die Datei AWS CLI installieren möchten. *Der Ordner muss bereits vorhanden sein, oder der Befehl schlägt fehl.* Das folgende XML-Beispiel mit dem Namen gibt das Installationsprogramm an*choices.xml*, das AWS CLI in dem Ordner installiert werden soll`/Users/myusername`, und erstellt dort einen Ordner mit dem Namen`aws-cli`.
```
choiceAttribute
customLocation
attributeSetting
/Users/myusername
choiceIdentifier
default
```
1. Laden Sie das `pkg`-Installationsprogramm mit dem `curl`-Befehl herunter. Die `-o`-Option gibt den Dateinamen an, in den das heruntergeladene Paket geschrieben wird. Im vorherigen Beispiel wird die Datei in `AWSCLIV2.pkg` im aktuellen Verzeichnis geschrieben.
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
```
1. Führen Sie das Standard-macOS-`installer`-Programm mit den folgenden Optionen aus:
+ Geben Sie den Namen des zu installierenden Pakets mithilfe des `-pkg`-Parameters an.
+ Geben Sie eine *aktuelle Benutzerinstallation* an, indem Sie den `-target`-Parameter auf `CurrentUserHomeDirectory` festlegen.
+ Geben Sie den Pfad (relativ zum aktuellen Ordner) und den Namen der XML-Datei an, die Sie im Parameter `-applyChoiceChangesXML` erstellt haben.
Im folgenden Beispiel wird das AWS CLI in dem Ordner installiert`/Users/myusername/aws-cli`.
```
$ installer -pkg AWSCLIV2.pkg \
-target CurrentUserHomeDirectory \
-applyChoiceChangesXML choices.xml
```
1. Da Standardbenutzerberechtigungen normalerweise nicht das Schreiben in Ordner im `$PATH` zulassen, versucht das Installationsprogramm in diesem Modus nicht, die Symlinks zu den Programmen `aws` und `aws_completer` hinzuzufügen. Damit der AWS CLI korrekt ausgeführt wird, müssen Sie die Symlinks nach Abschluss des Installationsprogramms manuell erstellen. Wenn Ihr `$PATH` einen Ordner enthält, in den Sie schreiben können, können Sie den folgenden Befehl ohne `sudo` ausführen, wenn Sie diesen Ordner als Pfad des Ziels angeben. Wenn Sie keinen beschreibbaren Ordner in Ihrem `$PATH` haben, müssen Sie `sudo` für Berechtigungen verwenden, um in den angegebenen Zielordner zu schreiben. Der Standardspeicherort für einen Symlink ist `/usr/local/bin/`. Ersetzen Sie `folder/installed` durch den Pfad für Ihre AWS CLI -Installation.
```
$ sudo ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ sudo ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
Nach Abschluss der Installation werden Debug-Protokolle in `/var/log/install.log` geschrieben.
1. Verwenden Sie die folgenden Befehle, um zu überprüfen, ob die Shell den `aws`-Befehl in Ihrem `$PATH` finden und ausführen kann.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Wenn der `aws`-Befehl nicht gefunden wird, müssen Sie möglicherweise Ihr Terminal neu starten oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
------
### Windows
#### Voraussetzungen für die Installation und Aktualisierung
+ Wir unterstützen die AWS CLI von Microsoft nicht unterstützten Versionen von 64-Bit-Windows.
+ Administratorrechte zur Installation von Software
#### Installieren oder aktualisieren Sie AWS CLI
Um Ihre aktuelle Installation von AWS CLI unter Windows zu aktualisieren, laden Sie bei jedem Update ein neues Installationsprogramm herunter, um frühere Versionen zu überschreiben. AWS CLI wird regelmäßig aktualisiert. Um zu sehen, wann die neueste Version veröffentlicht wurde, schauen Sie sich das [Changelog für AWS CLI Version 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) an *GitHub*.
1. Laden Sie das AWS CLI MSI-Installationsprogramm für Windows (64-Bit) herunter und führen Sie es aus:
[https://awscli.amazonaws.com/AWSCLIV2.msi](https://awscli.amazonaws.com/AWSCLIV2.msi)
Alternativ können Sie den `msiexec`-Befehl ausführen, um das MSI-Installationsprogramm auszuführen.
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2.msi
```
Informationen zu verschiedenen Parametern, die mit `msiexec` verwendet werden können, finden Sie unter [msiexec](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/msiexec) auf der *Microsoft-Docs*-Website. Sie können beispielsweise das Flag `/qn` für eine unbeaufsichtigte Installation verwenden.
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2.msi /qn
```
1. Zum Bestätigen der Installation öffnen Sie das **Startmenü**, suchen Sie nach `cmd`, um ein Eingabeaufforderungsfenster zu öffnen, und verwenden Sie an der Eingabeaufforderung den Befehl `aws --version`.
```
C:\> aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Wenn Windows das Programm nicht findet, müssen Sie möglicherweise das Eingabeaufforderungsfenster schließen und erneut öffnen, um den Pfad zu aktualisieren, oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
## Behebung von AWS CLI Installations- und Deinstallationsfehlern
Wenn Sie nach der Installation oder Deinstallation von auf Probleme stoßen AWS CLI, finden Sie die Schritte [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) zur Fehlerbehebung unter. Die wichtigsten Maßnahmen zur Fehlerbehebung finden Sie unter [Fehler aufgrund eines nicht gefundenen Befehls](cli-chap-troubleshooting.md#tshoot-install-not-found), [Der Befehl „`aws --version`“ gibt eine andere als die installierte Version zurück](cli-chap-troubleshooting.md#tshoot-install-wrong-version) und [Der Befehl "`aws --version`" gibt nach der Deinstallation von eine Version zurück AWS CLI](cli-chap-troubleshooting.md#tshoot-uninstall-1).
## Nächste Schritte
Nach der AWS CLI erfolgreichen Installation von können Sie Ihre heruntergeladenen Installationsdateien problemlos löschen. Nachdem Sie die Schritte unter abgeschlossen [Voraussetzungen für die Verwendung der AWS CLI Version 2](getting-started-prereqs.md) und installiert haben AWS CLI, sollten Sie eine ausführen[Einrichtung der AWS CLI](getting-started-quickstart.md).
# Installation früherer Versionen der AWS CLI Version 2
In diesem Thema wird beschrieben, wie frühere Versionen der AWS Command Line Interface Version 2 (AWS CLI) auf unterstützten Betriebssystemen installiert werden. Informationen zu den Versionen AWS CLI von Version 2 finden Sie im [Changelog für AWS CLI Version 2.](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) GitHub
AWS CLI Installationsanweisungen für Version 2:
## Linux
### Voraussetzungen für die Installation
+ Sie wissen, welche AWS CLI Version der Version 2 Sie installieren möchten. Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
+ Sie müssen das heruntergeladene Paket extrahieren oder „entpacken“ können. Wenn Ihr Betriebssystem nicht über den integrierten `unzip`-Befehl verfügt, verwenden Sie ein Äquivalent.
+ Die AWS CLI Version 2 verwendet`glibc`,`groff`, und`less`. Diese sind standardmäßig in den meisten großen Linux-Distributionen enthalten.
+ Wir unterstützen die AWS CLI Version 2 auf 64-Bit-Versionen neuerer Distributionen von CentOS, Fedora, Ubuntu, Amazon Linux 1, Amazon Linux 2 und Linux ARM.
+ Da AWS keine Repositorys von Drittanbietern verwaltet werden, können wir nicht garantieren, dass sie die neueste Version von enthalten. AWS CLI
### Installationsanleitungen
Folgen Sie diesen Schritten von der Befehlszeile aus, um das unter Linux AWS CLI zu installieren.
Wir stellen die Schritte in einer einfach zu kopierenden und einzufügenden Gruppe zur Verfügung, je nachdem, ob Sie 64-Bit-Linux oder Linux ARM verwenden. Lesen Sie die Beschreibungen der einzelnen Zeilen in den folgenden Schritten.
------
#### [ Linux x86 (64-bit) ]
**Anmerkung**
**(Optional)** Mit dem folgenden Befehlsblock wird der heruntergeladen und installiert, AWS CLI ohne zuvor die Integrität Ihres Downloads zu überprüfen. Gehen Sie wie folgt vor, um die Integrität Ihres Downloads zu überprüfen.
Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
Führen **Sie** die folgenden Befehle aus AWS CLI, um das zu installieren.
Um eine Version anzugeben, fügen Sie einen Bindestrich und die Versionsnummer an den Dateinamen an. In diesem Beispiel *2.0.30* würde der Dateiname für Version `awscli-exe-linux-x86_64-2.0.30.zip` zu dem folgenden Befehl führen:
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
Fügen Sie **zur Aktualisierung Ihrer aktuellen Installation** der AWS CLI Ihre vorhandenen Symlink- und Installationsinformationen hinzu, um den `install`-Befehl mit den Parametern `--bin-dir`, `--install-dir` und `--update` zu konstruieren. Der folgende Befehlsblock verwendet einen Beispiel-Symlink von */usr/local/bin* und ein Beispiel für den Speicherort des Installationsprogramms von*/usr/local/aws-cli*.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
------
#### [ Linux ARM ]
**Anmerkung**
**(Optional)** Der folgende Befehlsblock lädt den herunter und installiert ihn, AWS CLI ohne zuvor die Integrität Ihres Downloads zu überprüfen. Gehen Sie wie folgt vor, um die Integrität Ihres Downloads zu überprüfen.
Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
Führen **Sie** die folgenden Befehle aus AWS CLI, um das zu installieren.
Um eine Version anzugeben, fügen Sie einen Bindestrich und die Versionsnummer an den Dateinamen an. In diesem Beispiel *2.0.30* würde der Dateiname für Version `awscli-exe-linux-aarch64-2.0.30.zip` zu dem folgenden Befehl führen:
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
Fügen Sie **zur Aktualisierung Ihrer aktuellen Installation** der AWS CLI Ihre vorhandenen Symlink- und Installationsinformationen hinzu, um den `install`-Befehl mit den Parametern `--bin-dir`, `--install-dir` und `--update` zu konstruieren. Der folgende Befehlsblock verwendet einen Beispiel-Symlink von */usr/local/bin* und ein Beispiel für den Speicherort des Installationsprogramms von*/usr/local/aws-cli*.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
------
1. Laden Sie die Installationsdatei auf eine der folgenden Arten herunter:
------
#### [ Linux x86 (64-bit) ]
+ **Mit dem Befehl`curl`** – Die `-o`-Option gibt den Namen der Datei an, in die das heruntergeladene Paket geschrieben wird. Aufgrund der Optionen im folgenden Beispielbefehl wird die heruntergeladene Datei in das aktuelle Verzeichnis mit dem lokalen Namen `awscliv2.zip` geschrieben.
Um eine Version anzugeben, fügen Sie einen Bindestrich und die Versionsnummer an den Dateinamen an. In diesem Beispiel *2.0.30* würde der Dateiname für Version zu dem folgenden Befehl `awscli-exe-linux-x86_64-2.0.30.zip` führen:
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip" -o "awscliv2.zip"
```
Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
+ **Herunterladen über die URL** –
Laden Sie in Ihrem Browser Ihre spezifische Version von herunter, AWS CLI indem Sie einen Bindestrich und die Versionsnummer an den Dateinamen anhängen.
```
https://awscli.amazonaws.com/awscli-exe-linux-x86_64-version.number.zip
```
In diesem Beispiel wäre der Dateiname für Version awscli-exe-linux-x 86\$164-2.0.30.zip, was zu dem folgenden Link führen *2.0.30* würde: [https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip](https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip)
------
#### [ Linux ARM ]
+ **Mit dem Befehl`curl`** – Die `-o`-Option gibt den Namen der Datei an, in die das heruntergeladene Paket geschrieben wird. Aufgrund der Optionen im folgenden Beispielbefehl wird die heruntergeladene Datei in das aktuelle Verzeichnis mit dem lokalen Namen `awscliv2.zip` geschrieben.
Um eine Version anzugeben, fügen Sie einen Bindestrich und die Versionsnummer an den Dateinamen an. In diesem Beispiel *2.0.30* würde der Dateiname für Version zu dem folgenden Befehl `awscli-exe-linux-aarch64-2.0.30.zip` führen:
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
+ **Herunterladen über die URL** –
Laden Sie in Ihrem Browser Ihre spezifische Version von herunter, AWS CLI indem Sie einen Bindestrich und die Versionsnummer an den Dateinamen anhängen.
```
https://awscli.amazonaws.com/awscli-exe-linux-aarch64-version.number.zip
```
In diesem Beispiel *2.0.30* würde der Dateiname für die Version zu dem folgenden Link `awscli-exe-linux-aarch64-2.0.30.zip` führen: [https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip](https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip)
------
1. **(Optional) Überprüfen der Integrität Ihrer heruntergeladenen Zip-Datei**
Wenn Sie sich `.zip` in den obigen Schritten dafür entschieden haben, das AWS CLI Installationspaket manuell herunterzuladen, können Sie die folgenden Schritte ausführen, um die Signaturen mithilfe des `GnuPG` Tools zu überprüfen.
Die `.zip` Dateien des AWS CLI Installationspakets sind mithilfe von PGP-Signaturen kryptografisch signiert. Wenn die Dateien beschädigt oder verändert wurden, schlägt diese Verifizierung fehl und Sie sollten nicht mit der Installation fortfahren.
1. Laden Sie den `gpg`-Befehl herunter und installieren Sie diesen mit Ihrem Paket-Manager. Weitere Informationen zu `GnuPG` finden Sie auf der [GnuPG-Website](https://www.gnupg.org/).
1. Um die öffentliche Schlüsseldatei zu erstellen, müssen Sie eine Textdatei erstellen und den folgenden Text einfügen.
```
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBF2Cr7UBEADJZHcgusOJl7ENSyumXh85z0TRV0xJorM2B/JL0kHOyigQluUG
ZMLhENaG0bYatdrKP+3H91lvK050pXwnO/R7fB/FSTouki4ciIx5OuLlnJZIxSzx
PqGl0mkxImLNbGWoi6Lto0LYxqHN2iQtzlwTVmq9733zd3XfcXrZ3+LblHAgEt5G
TfNxEKJ8soPLyWmwDH6HWCnjZ/aIQRBTIQ05uVeEoYxSh6wOai7ss/KveoSNBbYz
gbdzoqI2Y8cgH2nbfgp3DSasaLZEdCSsIsK1u05CinE7k2qZ7KgKAUIcT/cR/grk
C6VwsnDU0OUCideXcQ8WeHutqvgZH1JgKDbznoIzeQHJD238GEu+eKhRHcz8/jeG
94zkcgJOz3KbZGYMiTh277Fvj9zzvZsbMBCedV1BTg3TqgvdX4bdkhf5cH+7NtWO
lrFj6UwAsGukBTAOxC0l/dnSmZhJ7Z1KmEWilro/gOrjtOxqRQutlIqG22TaqoPG
fYVN+en3Zwbt97kcgZDwqbuykNt64oZWc4XKCa3mprEGC3IbJTBFqglXmZ7l9ywG
EEUJYOlb2XrSuPWml39beWdKM8kzr1OjnlOm6+lpTRCBfo0wa9F8YZRhHPAkwKkX
XDeOGpWRj4ohOx0d2GWkyV5xyN14p2tQOCdOODmz80yUTgRpPVQUtOEhXQARAQAB
tCFBV1MgQ0xJIFRlYW0gPGF3cy1jbGlAYW1hem9uLmNvbT6JAlQEEwEIAD4CGwMF
CwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQT7Xbd/1cEYuAURraimMQrMRnJHXAUC
aGveYQUJDMpiLAAKCRCmMQrMRnJHXKBYD/9Ab0qQdGiO5hObchG8xh8Rpb4Mjyf6
0JrVo6m8GNjNj6BHkSc8fuTQJ/FaEhaQxj3pjZ3GXPrXjIIVChmICLlFuRXYzrXc
Pw0lniybypsZEVai5kO0tCNBCCFuMN9RsmmRG8mf7lC4FSTbUDmxG/QlYK+0IV/l
uJkzxWa+rySkdpm0JdqumjegNRgObdXHAQDWlubWQHWyZyIQ2B4U7AxqSpcdJp6I
S4Zds4wVLd1WE5pquYQ8vS2cNlDm4QNg8wTj58e3lKN47hXHMIb6CHxRnb947oJa
pg189LLPR5koh+EorNkA1wu5mAJtJvy5YMsppy2y/kIjp3lyY6AmPT1posgGk70Z
CmToEZ5rbd7ARExtlh76A0cabMDFlEHDIK8RNUOSRr7L64+KxOUegKBfQHb9dADY
qqiKqpCbKgvtWlds909Ms74JBgr2KwZCSY1HaOxnIr4CY43QRqAq5YHOay/mU+6w
hhmdF18vpyK0vfkvvGresWtSXbag7Hkt3XjaEw76BzxQH21EBDqU8WJVjHgU6ru+
DJTs+SxgJbaT3hb/vyjlw0lK+hFfhWKRwgOXH8vqducF95NRSUxtS4fpqxWVaw3Q
V2OWSjbne99A5EPEySzryFTKbMGwaTlAwMCwYevt4YT6eb7NmFhTx0Fis4TalUs+
j+c7Kg92pDx2uQ==
=OBAt
-----END PGP PUBLIC KEY BLOCK-----
```
Als Referenz finden Sie im Folgenden die Details des öffentlichen Schlüssels.
```
Key ID: A6310ACC4672
Type: RSA
Size: 4096/4096
Created: 2019-09-18
Expires: 2026-07-07
User ID: AWS CLI Team
Key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
1. Importieren Sie den AWS CLI öffentlichen Schlüssel mit dem folgenden Befehl und ersetzen Sie ihn durch den Dateinamen des öffentlichen *public-key-file-name* Schlüssels, den Sie erstellt haben.
```
$ gpg --import public-key-file-name
gpg: /home/username/.gnupg/trustdb.gpg: trustdb created
gpg: key A6310ACC4672475C: public key "AWS CLI Team " imported
gpg: Total number processed: 1
gpg: imported: 1
```
1. Laden Sie die AWS CLI Signaturdatei für das Paket herunter, das Sie heruntergeladen haben. Sie hat denselben Pfad und denselben Namen wie die `.zip`-Datei, der sie entspricht, hat aber die Erweiterung `.sig`. In den folgenden Beispielen speichern wir sie im aktuellen Verzeichnis als Datei namens `awscliv2.sig`.
------
#### [ Linux x86 (64-bit) ]
Verwenden Sie **für die AWS CLI neueste Version von** den folgenden Befehlsblock:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip.sig
```
**Hängen Sie für eine bestimmte Version von** einen Bindestrich und die Versionsnummer an den Dateinamen an. AWS CLI In diesem Beispiel *2.0.30* würde der Dateiname für Version zu dem folgenden Befehl `awscli-exe-linux-x86_64-2.0.30.zip.sig` führen:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip.sig
```
Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
------
#### [ Linux ARM ]
Verwenden Sie **für die neueste Version von den AWS CLI** folgenden Befehlsblock:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip.sig
```
**Hängen Sie für eine bestimmte Version von** einen Bindestrich und die Versionsnummer an den Dateinamen an. AWS CLI In diesem Beispiel *2.0.30* würde der Dateiname für Version zu dem folgenden Befehl `awscli-exe-linux-aarch64-2.0.30.zip.sig` führen:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip.sig
```
Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://github.com/aws/aws-cli/blob/v2/CHANGELOG.rst?plain=1)
------
1. Überprüfen Sie die Signatur und übergeben Sie sowohl den heruntergeladenen `.sig`- als auch den `.zip`-Dateinamen als Parameter an den `gpg`-Befehl.
```
$ gpg --verify awscliv2.sig awscliv2.zip
```
Die Ausgabe sollte in etwa folgendermaßen aussehen:
```
gpg: Signature made Mon Nov 4 19:00:01 2019 PST
gpg: using RSA key FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
gpg: Good signature from "AWS CLI Team " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
**Wichtig**
Die Warnung in der Ausgabe wird erwartet und ist kein Hinweis auf ein Problem. Das liegt daran, dass zwischen Ihrem persönlichen PGP-Schlüssel (falls Sie einen haben) und dem PGP-Schlüssel keine Vertrauenskette besteht. AWS CLI Weitere Informationen finden Sie unter [Web of trust](https://en.wikipedia.org/wiki/Web_of_trust) (Netz des Vertrauens).
1. Entpacken Sie das Installationsprogramm. Wenn Ihre Linux-Distribution keinen integrierten `unzip`-Befehl aufweist, verwenden Sie ein Äquivalent, um es zu entpacken. Der folgende Beispielbefehl entpackt das Paket und erstellt ein Verzeichnis mit dem Namen `aws` im aktuellen Verzeichnis.
```
$ unzip awscliv2.zip
```
1. Führen Sie das Installationsprogramm aus. Der Installationsbefehl verwendet eine Datei namens `install` im neu entpackten `aws`-Verzeichnis. Standardmäßig werden alle Dateien unter `/usr/local/aws-cli` installiert und ein symbolischer Link wird in `/usr/local/bin` erstellt. Der Befehl enthält `sudo`, um diesen Verzeichnissen Schreibberechtigungen zu erteilen.
```
$ sudo ./aws/install
```
Sie können ohne `sudo` installieren, wenn Sie Ordner angeben, für die Sie bereits über Schreibberechtigungen verfügen. Verwenden Sie die folgenden Anweisungen für den `install`-Befehl, um den Installationsort anzugeben:
+ Stellen Sie sicher, dass die Pfade, die Sie zu den Parametern `-i` und `-b` angeben, keine Volume- oder Verzeichnisnamen mit Leerstellen oder Leerräumen enthalten. Wenn ein Leerzeichen vorhanden ist, schlägt die Installation fehl.
+ `--install-dir` oder `-i` – Diese Option gibt das Verzeichnis an, in den alle Dateien kopiert werden sollen.
Der Standardwert ist `/usr/local/aws-cli`.
+ `--bin-dir` oder `-b` – Diese Option gibt an, dass das `aws`-Hauptprogramm im Installationsordner mit der Datei `aws` im angegebenen Pfad symbolisch verknüpft ist. Sie müssen über Schreibberechtigungen für das angegebene Verzeichnis verfügen. Wenn Sie einen Symlink zu einem Verzeichnis erstellen, das sich bereits im Pfad befindet, ist es nicht notwendig, das Installationsverzeichnis der `$PATH`-Variablen des Benutzers hinzuzufügen.
Der Standardwert ist `/usr/local/bin`.
```
$ ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
```
**Anmerkung**
Um Ihre aktuelle Installation von AWS CLI Version 2 auf eine neuere Version zu aktualisieren, fügen Sie Ihren vorhandenen Symlink und Ihre Installationsinformationen hinzu, um den `install` Befehl mit dem Parameter zu erstellen. `--update`
```
$ sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
Gehen Sie wie folgt vor, um den vorhandenen Symlink und das Installationsverzeichnis zu suchen:
Verwenden Sie den `which`-Befehl, um Ihren Symlink zu finden. Dadurch erhalten Sie den Pfad, der mit dem `--bin-dir`-Parameter verwendet werden soll.
```
$ which aws
/usr/local/bin/aws
```
Verwenden Sie den `ls`-Befehl, um das Verzeichnis zu finden, auf das Ihr Symlink verweist. Dadurch erhalten Sie den Pfad, der mit dem `--install-dir`-Parameter verwendet werden soll.
```
$ ls -l /usr/local/bin/aws
lrwxrwxrwx 1 ec2-user ec2-user 49 Oct 22 09:49 /usr/local/bin/aws -> /usr/local/aws-cli/v2/current/bin/aws
```
1. Bestätigen Sie die Installation mit dem folgenden Befehl.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Wenn der `aws`-Befehl nicht gefunden wird, müssen Sie möglicherweise Ihr Terminal neu starten oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
## macOS
### Voraussetzungen für die Installation
+ Sie wissen, welche Version der AWS CLI Version 2 Sie installieren möchten. Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://github.com/aws/aws-cli/blob/v2/CHANGELOG.rst?plain=1)
+ Wir unterstützen AWS CLI Version 2 auf von Apple unterstützten Versionen von 64-Bit-MacOS.
+ Da AWS keine Repositorys von Drittanbietern verwaltet werden, können wir nicht garantieren, dass sie die neueste Version von enthalten. AWS CLI
### Installationsanleitungen
Sie können die AWS CLI Version 2 auf macOS auf folgende Weise installieren.
------
#### [ GUI installer ]
Die folgenden Schritte zeigen, wie Sie mithilfe der standardmäßigen macOS-Benutzeroberfläche und Ihres Browsers die neueste Version der AWS CLI Version 2 installieren oder aktualisieren. Wenn Sie auf die neueste Version aktualisieren, verwenden Sie dieselbe Installationsmethode, die Sie für die aktuelle Version verwendet haben.
1. Laden Sie in Ihrem Browser Ihre spezifische Version von herunter, AWS CLI indem Sie einen Bindestrich und die Versionsnummer an den Dateinamen anhängen.
```
https://awscli.amazonaws.com/AWSCLIV2-version.number.pkg
```
In diesem Beispiel *2.0.30* würde der Dateiname für die Version zu dem folgenden Link `AWSCLIV2-2.0.30.pkg` führen:. [https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg](https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg)
1. Führen Sie die heruntergeladene Datei aus und folgen Sie den Anweisungen auf dem Bildschirm. Sie können die AWS CLI Version 2 auf folgende Weise installieren:
+ **Für alle Benutzer auf dem Computer (erfordert `sudo`)**
+ Sie können in einem beliebigen Ordner installieren oder den empfohlenen Standardordner `/usr/local/aws-cli` auswählen.
+ Das Installationsprogramm erstellt automatisch einen Symlink unter `/usr/local/bin/aws`, der mit dem Hauptprogramm in dem von Ihnen gewählten Installationsordner verknüpft ist.
+ **Nur für den aktuellen Benutzer (erfordert nicht `sudo`)**
+ Sie können die Installation in jedem beliebigen Ordner vornehmen, für den Sie Schreibberechtigung haben.
+ Aufgrund der standardmäßigen Benutzerberechtigungen müssen Sie nach Abschluss des Installationsprogramms manuell eine Symlink-Datei in Ihrem `$PATH` erstellen, die auf die Programme `aws` und `aws_completer` verweist, indem Sie die folgenden Befehle bei der Eingabeaufforderung verwenden. Wenn Ihr `$PATH` einen Ordner enthält, in den Sie schreiben können, können Sie den folgenden Befehl ohne `sudo` ausführen, wenn Sie diesen Ordner als Pfad des Ziels angeben. Wenn Sie sich in Ihrem `$PATH` kein Ordner befindet, in den geschrieben werden kann, müssen Sie `sudo` in den Befehlen verwenden, um Berechtigungen zum Schreiben in den angegebenen Zielordner zu erhalten. Der Standardspeicherort für einen Symlink ist `/usr/local/bin/`.
```
$ sudo ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ sudo ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
**Anmerkung**
Sie können Debug-Protokolle für die Installation anzeigen, indem Sie **STRG\$1L** an einer beliebigen Stelle im Installationsprogramm drücken. Dadurch wird ein Protokollbereich geöffnet, in dem Sie das Protokoll filtern und speichern können. Die Protokolldatei wird ebenfalls automatisch in `/var/log/install.log` gespeichert.
1. Verwenden Sie die folgenden Befehle, um zu überprüfen, ob die Shell den `aws`-Befehl in Ihrem `$PATH` finden und ausführen kann.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Wenn der `aws`-Befehl nicht gefunden wird, müssen Sie möglicherweise Ihr Terminal neu starten oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
------
#### [ Command line installer - All users ]
Wenn Sie über die `sudo` erforderlichen Berechtigungen verfügen, können Sie AWS CLI Version 2 für alle Benutzer auf dem Computer installieren. Wir stellen die Schritte in einer Gruppe bereit, die einfach zu kopieren und einzufügen ist. Lesen Sie die Beschreibungen der einzelnen Zeilen in den folgenden Schritten.
Fügen Sie für eine bestimmte Version von einen Bindestrich und die Versionsnummer an den Dateinamen an. AWS CLI In diesem Beispiel *2.0.30* würde der Dateiname für Version zu dem folgenden Befehl `AWSCLIV2-2.0.30.pkg` führen:
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg" -o "AWSCLIV2.pkg"
$ sudo installer -pkg AWSCLIV2.pkg -target /
```
1. Laden Sie die Datei mit dem `curl`-Befehl herunter. Die `-o`-Option gibt den Dateinamen an, in den das heruntergeladene Paket geschrieben wird. Im vorherigen Beispiel wird die Datei in `AWSCLIV2.pkg` im aktuellen Verzeichnis geschrieben.
Hängen Sie für eine bestimmte Version von einen Bindestrich und die Versionsnummer an den Dateinamen an. AWS CLI In diesem Beispiel *2.0.30* würde der Dateiname für Version zu dem folgenden Befehl `AWSCLIV2-2.0.30.pkg` führen:
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg" -o "AWSCLIV2.pkg"
```
Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
1. Führen Sie das Standard-macOS-`installer`-Programm aus und geben Sie die heruntergeladene `.pkg`-Datei als Quelle an. Verwenden Sie den `-pkg`-Parameter, um den Namen des zu installierenden Pakets und den `-target /`-Parameter für das Laufwerk, auf dem das Paket installiert werden soll. Die Dateien werden in `/usr/local/aws-cli` installiert, und in `/usr/local/bin` wird automatisch ein Symlink erstellt. Sie müssen dem Befehl `sudo` hinzufügen, um diesen Ordnern Schreibberechtigungen zu erteilen.
```
$ sudo installer -pkg ./AWSCLIV2.pkg -target /
```
Nach Abschluss der Installation werden Debug-Protokolle in `/var/log/install.log` geschrieben.
1. Verwenden Sie die folgenden Befehle, um zu überprüfen, ob die Shell den `aws`-Befehl in Ihrem `$PATH` finden und ausführen kann.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Wenn der `aws`-Befehl nicht gefunden wird, müssen Sie möglicherweise Ihr Terminal neu starten oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
------
#### [ Command line - Current user ]
1. Um anzugeben, in welchem Ordner das installiert AWS CLI ist, müssen Sie eine XML-Datei erstellen. Diese Datei ist eine XML-formatierte Datei, die ähnlich wie im folgenden Beispiel aussieht. Lassen Sie alle Werte unverändert, außer dass Sie den Pfad */Users/myusername* in Zeile 9 durch den Pfad zu dem Ordner ersetzen müssen, in dem AWS CLI Version 2 installiert werden soll. *Der Ordner muss bereits vorhanden sein, oder der Befehl schlägt fehl.* Dieses XML-Beispiel gibt an, dass das Installationsprogramm die AWS CLI in dem Ordner installiert `/Users/myusername` und dort einen Ordner mit dem Namen erstellt`aws-cli`.
```
choiceAttribute
customLocation
attributeSetting
/Users/myusername
choiceIdentifier
default
```
1. Laden Sie das `pkg`-Installationsprogramm mit dem `curl`-Befehl herunter. Die `-o`-Option gibt den Dateinamen an, in den das heruntergeladene Paket geschrieben wird. Im vorherigen Beispiel wird die Datei in `AWSCLIV2.pkg` im aktuellen Verzeichnis geschrieben.
Hängen Sie für die AWS CLI spezifische Version von einen Bindestrich und die Versionsnummer an den Dateinamen an. In diesem Beispiel *2.0.30* würde der Dateiname für Version zu dem folgenden Befehl `AWSCLIV2-2.0.30.pkg` führen:
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg" -o "AWSCLIV2.pkg"
```
Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
1. Führen Sie das Standard-macOS-`installer`-Programm mit den folgenden Optionen aus:
+ Geben Sie den Namen des zu installierenden Pakets mithilfe des `-pkg`-Parameters an.
+ Geben Sie eine *aktuelle Benutzerinstallation* an, indem Sie den `-target`-Parameter auf `CurrentUserHomeDirectory` festlegen.
+ Geben Sie den Pfad (relativ zum aktuellen Ordner) und den Namen der XML-Datei an, die Sie im Parameter `-applyChoiceChangesXML` erstellt haben.
Im folgenden Beispiel wird der AWS CLI im Ordner `/Users/myusername/aws-cli` installiert.
```
$ installer -pkg AWSCLIV2.pkg \
-target CurrentUserHomeDirectory \
-applyChoiceChangesXML choices.xml
```
1. Da Standardbenutzerberechtigungen normalerweise nicht das Schreiben in Ordner im `$PATH` zulassen, versucht das Installationsprogramm in diesem Modus nicht, die Symlinks zu den Programmen `aws` und `aws_completer` hinzuzufügen. Damit der AWS CLI korrekt ausgeführt wird, müssen Sie die Symlinks nach Abschluss des Installationsprogramms manuell erstellen. Wenn Ihr `$PATH` einen Ordner enthält, in den Sie schreiben können, können Sie den folgenden Befehl ohne `sudo` ausführen, wenn Sie diesen Ordner als Pfad des Ziels angeben. Wenn Sie keinen beschreibbaren Ordner in Ihrem `$PATH` haben, müssen Sie `sudo` für Berechtigungen verwenden, um in den angegebenen Zielordner zu schreiben. Der Standardspeicherort für einen Symlink ist `/usr/local/bin/`.
```
$ sudo ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ sudo ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
Nach Abschluss der Installation werden Debug-Protokolle in `/var/log/install.log` geschrieben.
1. Verwenden Sie die folgenden Befehle, um zu überprüfen, ob die Shell den `aws`-Befehl in Ihrem `$PATH` finden und ausführen kann.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Wenn der `aws`-Befehl nicht gefunden wird, müssen Sie möglicherweise Ihr Terminal neu starten oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
------
## Windows
### Voraussetzungen für die Installation
+ Sie wissen, welche Version der AWS CLI Version 2 Sie installieren möchten. Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
+ Wir unterstützen die AWS CLI von Microsoft nicht unterstützten Versionen von 64-Bit-Windows.
+ Administratorrechte zur Installation von Software
### Installationsanleitungen
Um Ihre aktuelle Installation von AWS CLI Version 2 unter Windows zu aktualisieren, laden Sie bei jedem Update ein neues Installationsprogramm herunter, um frühere Versionen zu überschreiben. AWS CLI wird regelmäßig aktualisiert. Wann die neueste Version veröffentlicht wurde, finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
1. Laden Sie das AWS CLI MSI-Installationsprogramm für Windows (64-Bit) herunter und führen Sie es auf eine der folgenden Arten aus:
+ **Herunterladen und Ausführen des MSI-Installationsprogramms:** Um Ihren Download-Link für eine bestimmte Version von zu erstellen AWS CLI, fügen Sie einen Bindestrich und die Versionsnummer an den Dateinamen an.
```
https://awscli.amazonaws.com/AWSCLIV2-version.number.msi
```
In diesem Beispiel *2.0.30* würde der Dateiname für die Version zu dem folgenden Link `AWSCLIV2-2.0.30.msi` führen:. [https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi](https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi)
+ **Verwenden des msiexec-Befehls:** Sie können auch das MSI-Installationsprogramm verwenden, indem Sie den Link zum `msiexec`-Befehl hinzufügen. Hängen Sie für eine bestimmte Version von einen Bindestrich und die Versionsnummer an den Dateinamen an. AWS CLI
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2-version.number.msi
```
In diesem Beispiel *2.0.30* würde der Dateiname für Version zu dem folgenden Link `AWSCLIV2-2.0.30.msi` führen. [https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi](https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi)
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi
```
Informationen zu verschiedenen Parametern, die mit `msiexec` verwendet werden können, finden Sie unter [msiexec](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/msiexec) auf der *Microsoft-Docs*-Website.
Eine Liste der Versionen finden Sie im [Changelog für AWS CLI Version 2. *GitHub*](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst)
1. Zum Bestätigen der Installation öffnen Sie das **Startmenü**, suchen Sie nach `cmd`, um ein Eingabeaufforderungsfenster zu öffnen, und verwenden Sie an der Eingabeaufforderung den Befehl `aws --version`.
```
C:\> aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Wenn Windows das Programm nicht findet, müssen Sie möglicherweise das Eingabeaufforderungsfenster schließen und erneut öffnen, um den Pfad zu aktualisieren, oder die Maßnahmen zur Fehlerbehebung unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) befolgen.
## Behebung von AWS CLI Installations- und Deinstallationsfehlern
Wenn Sie nach der Installation oder Deinstallation von auf Probleme stoßen AWS CLI, finden Sie die Schritte [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) zur Fehlerbehebung unter. Die wichtigsten Maßnahmen zur Fehlerbehebung finden Sie unter [Fehler aufgrund eines nicht gefundenen Befehls](cli-chap-troubleshooting.md#tshoot-install-not-found), [Der Befehl „`aws --version`“ gibt eine andere als die installierte Version zurück](cli-chap-troubleshooting.md#tshoot-install-wrong-version) und [Der Befehl "`aws --version`" gibt nach der Deinstallation von eine Version zurück AWS CLI](cli-chap-troubleshooting.md#tshoot-uninstall-1).
## Nächste Schritte
Nach Abschluss der Schritte unter [Voraussetzungen für die Verwendung der AWS CLI Version 2](getting-started-prereqs.md) und der Installation der AWS CLI sollten Sie einen [Einrichtung der AWS CLI](getting-started-quickstart.md) ausführen.
# AWS CLI Aus dem Quellcode erstellen und installieren
In diesem Thema wird beschrieben, wie Sie die neueste Version der AWS Command Line Interface (AWS CLI) auf unterstützten Betriebssystemen aus der Quelle installieren oder aktualisieren.
Informationen zu den neuesten Versionen von AWS CLI finden Sie im [Changelog für AWS CLI Version 2.](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) GitHub
**Wichtig**
AWS CLI Die Versionen 1 und 2 verwenden denselben `aws` Befehlsnamen. Wenn Sie AWS CLI Version 1 bereits installiert haben, finden Sie weitere Informationen unter[Migrationsleitfaden für die AWS CLI Version 2](cliv2-migration.md).
**Topics**
+ [Warum aus der Quelle erstellen?](#source-getting-started-install-why)
+ [Schnelle Schritte](#source-getting-started-install-quicksteps)
+ [Schritt 1: Einrichten aller Anforderungen](#source-getting-started-install-reqs)
+ [Schritt 2: Konfiguration der AWS CLI Quellinstallation](#source-getting-started-install-config)
+ [Schritt 3: Aufbau des AWS CLI](#source-getting-started-install-build)
+ [Schritt 4: Installation des AWS CLI](#source-getting-started-install-instructions)
+ [Schritt 5: Überprüfen der Installation AWS CLI](#source-getting-started-install-verify)
+ [Workflow-Beispiele](#source-getting-started-install-workflows)
+ [Behebung von AWS CLI Installations- und Deinstallationsfehlern](#source-install-tshoot)
+ [Nächste Schritte](#source-install-next-steps)
## Warum aus der Quelle erstellen?
Das AWS CLI ist [als vorgefertigtes Installationsprogramm für die meisten Plattformen und Umgebungen sowie als Docker-Image verfügbar](getting-started-install.md).
Im Allgemeinen decken diese Installationsprogramme die meisten Anwendungsfälle ab. Die Anweisungen für die Installation aus der Quelle sollen bei den Anwendungsfällen helfen, die unsere Installationsprogramme nicht abdecken. Einige dieser Anwendungsfälle sind:
+ Die vordefinierten Installationsprogramme unterstützen Ihre Umgebung nicht. Beispielsweise wird ARM 32-Bit von den vordefinierten Installationsprogrammen nicht unterstützt.
+ Die vordefinierten Installationsprogramme haben Abhängigkeiten, die Ihrer Umgebung fehlen. Zum Beispiel verwendet Alpine Linux [https://musl.libc.org/](https://musl.libc.org/), aber die aktuellen Installationsprogramme erfordern `glibc`, sodass die vordefinierten Installationsprogramme nicht sofort funktionieren.
+ Die vordefinierten Installationsprogramme benötigen Ressourcen, auf die Ihre Umgebung den Zugriff beschränkt. Beispielsweise gewähren sicherheitsgeschützte Systeme möglicherweise keine Berechtigungen für gemeinsam genutzten Speicher. Dies ist für das eingefrorene `aws`-Installationsprogramm jedoch erforderlich.
+ Die vordefinierten Installationsprogramme sind oft ein Hindernis für die Maintainer in Paketmanagern, da die vollständige Kontrolle über den Erstellungsprozess von Code und Paketen bevorzugt wird. Das Erstellen aus der Quelle ermöglicht es Distributions-Maintainern, den Prozess zu optimieren, um die AWS CLI stets auf dem neuesten Stand zu halten. Durch die Aktivierung von Maintainers erhalten Kunden mehr up-to-date Versionen von, AWS CLI wenn sie über einen Paketmanager eines Drittanbieters wie, und installiert werden. `brew` `yum` `apt`
+ Kunden, die AWS CLI Funktionen patchen, müssen das AWS CLI aus dem Quellcode erstellen und installieren. Dies ist besonders wichtig für Community-Mitglieder, die Änderungen, die sie an der Quelle vorgenommen haben, testen möchten, bevor sie die Änderung zum AWS CLI GitHub Repository beitragen.
## Schnelle Schritte
**Anmerkung**
Es wird davon ausgegangen, dass alle Codebeispiele aus dem Stammverzeichnis des Quellverzeichnisses ausgeführt werden.
Um den Quelltext zu erstellen und AWS CLI zu installieren, folgen Sie den Schritten in diesem Abschnitt. Die AWS CLI nutzt [GNU Autotools](https://www.gnu.org/software/automake/faq/autotools-faq.html) zur Installation aus der Quelle. Im einfachsten Fall AWS CLI kann das aus dem Quellcode installiert werden, indem die standardmäßigen Beispielbefehle im Stammverzeichnis des AWS CLI GitHub Repositorys ausgeführt werden.
1. [Richten Sie alle Anforderungen für Ihre Umgebung ein.](#source-getting-started-install-reqs) Dies beinhaltet die Möglichkeit, von [GNU Autotools](https://www.gnu.org/software/automake/faq/autotools-faq.html) generierte Dateien auszuführen, wobei Python 3.8 oder höher installiert ist.
1. Navigieren Sie in Ihrem Terminal zur obersten Ebene des AWS CLI Quellordners und führen Sie den `./configure` Befehl aus. Dieser Befehl überprüft das System auf alle erforderlichen Abhängigkeiten und generiert eine `Makefile` anhand der erkannten und angegebenen Konfigurationen für die Erstellung und Installation der AWS CLI .
------
#### [ Linux and macOS ]
Das folgende `./configure` Befehlsbeispiel legt die Build-Konfiguration für die AWS CLI Verwendung der Standardeinstellungen fest.
```
$ ./configure
```
------
#### [ Windows PowerShell ]
Bevor Sie Befehle aufrufen MSYS2, müssen Sie Ihr aktuelles Arbeitsverzeichnis beibehalten:
```
PS C:\> $env:CHERE_INVOKING = 'yes'
```
Verwenden Sie dann das folgende `./configure` Befehlsbeispiel, um die Build-Konfiguration für die AWS CLI Verwendung Ihres lokalen Pfads zu Ihrer ausführbaren Python-Datei, die Installation in C:\$1Program Files\$1 AWSCLI und das Herunterladen aller Abhängigkeiten festzulegen.
```
PS C:\> C:\msys64\usr\bin\bash -lc " PYTHON='C:\path\to\python.exe' ./configure --prefix='C:\Program Files\AWSCLI' --with-download-deps "
```
------
Einzelheiten, verfügbare Konfigurationsoptionen und Informationen zu Standardeinstellungen finden Sie im Abschnitt [Schritt 2: Konfiguration der AWS CLI Quellinstallation](#source-getting-started-install-config).
1. Führen Sie den Befehl `make` aus. Dieser Befehl erstellt die AWS CLI gemäß Ihren Konfigurationseinstellungen.
Das folgende `make` Befehlsbeispiel erstellt mit Standardoptionen und verwendet Ihre vorhandenen `./configure`-Einstellungen.
------
#### [ Linux and macOS ]
```
$ make
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "make"
```
------
Einzelheiten und verfügbare Build-Optionen finden Sie im Abschnitt [Schritt 3: Aufbau des AWS CLI](#source-getting-started-install-build).
1. Führen Sie den Befehl `make install` aus. Mit diesem Befehl wird Ihr Build AWS CLI an dem konfigurierten Speicherort auf Ihrem System installiert.
Das folgende `make install` Befehlsbeispiel installiert Ihren Build AWS CLI und erstellt mithilfe der Standardbefehlseinstellungen Symlinks an Ihren konfigurierten Speicherorten.
------
#### [ Linux and macOS ]
```
$ make install
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "make install"
```
Fügen Sie nach der Installation den Pfad wie AWS CLI folgt hinzu:
```
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
```
------
Einzelheiten und verfügbare Installationsoptionen finden Sie im Abschnitt [Schritt 4: Installation des AWS CLI](#source-getting-started-install-instructions).
1. Bestätigen Sie die AWS CLI erfolgreiche Installation mit dem folgenden Befehl:
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Schritte zur Behebung von Installationsfehlern finden Sie im Abschnitt [Behebung von AWS CLI Installations- und Deinstallationsfehlern](#source-install-tshoot).
## Schritt 1: Einrichten aller Anforderungen
Um den AWS CLI From-Quellcode zu erstellen, müssen Sie zuvor Folgendes erledigen:
**Anmerkung**
Es wird davon ausgegangen, dass alle Codebeispiele aus dem Stammverzeichnis des Quellverzeichnisses ausgeführt werden.
1. Laden Sie die AWS CLI Quelle herunter, indem Sie entweder das AWS CLI GitHub Repository forken oder den Quell-Tarball herunterladen. Siehe eine der folgenden Anweisungen:
+ Forke und klone das [AWS CLI Repository](https://github.com/aws/aws-cli) von. *GitHub* Weitere Informationen finden Sie in den *GitHub Dokumenten* unter [Forken eines Repositorys](https://docs.github.com/en/get-started/quickstart/fork-a-repo).
+ Laden Sie den neuesten Quell-Tarball unter [https://awscli.amazonaws.com/awscli.tar.gz](https://awscli.amazonaws.com/awscli.tar.gz) herunter und extrahieren Sie den Inhalt mit folgenden Befehlen:
```
$ curl "https://awscli.amazonaws.com/awscli.tar.gz" -o "awscli.tar.gz"
$ tar -xzf awscli.tar.gz
```
**Anmerkung**
Verwenden Sie das folgende Linkformat, um eine bestimmte Version herunterzuladen: [https://awscli.amazonaws.com*versionnumber*/awscli-](https://awscli.amazonaws.com/awscli.tar.gz) .tar.gz
[Für Version 2.10.0 lautet der Link beispielsweise wie folgt: /awscli- .tar.gz https://awscli.amazonaws.com *2.10.0*](https://awscli.amazonaws.com/awscli.tar.gz)
Quellversionen sind ab Version **2.10.0** von der AWS CLI verfügbar.
**(Optional) Überprüfen der Integrität Ihrer heruntergeladenen Zip-Datei anhand der folgenden Schritten:**
1. Sie können die folgenden Schritte verwenden, um die Signaturen mithilfe des `GnuPG`-Tools zu überprüfen.
Die AWS CLI Installationspaketdateien sind mithilfe von PGP-Signaturen kryptografisch signiert. `.zip` Wenn die Dateien beschädigt oder verändert wurden, schlägt diese Verifizierung fehl und Sie sollten nicht mit der Installation fortfahren.
1. Laden Sie den `gpg`-Befehl herunter und installieren Sie diesen mit Ihrem Paket-Manager. Weitere Informationen zu `GnuPG` finden Sie auf der [GnuPG-Website](https://www.gnupg.org/).
1. Um die öffentliche Schlüsseldatei zu erstellen, müssen Sie eine Textdatei erstellen und den folgenden Text einfügen.
```
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBF2Cr7UBEADJZHcgusOJl7ENSyumXh85z0TRV0xJorM2B/JL0kHOyigQluUG
ZMLhENaG0bYatdrKP+3H91lvK050pXwnO/R7fB/FSTouki4ciIx5OuLlnJZIxSzx
PqGl0mkxImLNbGWoi6Lto0LYxqHN2iQtzlwTVmq9733zd3XfcXrZ3+LblHAgEt5G
TfNxEKJ8soPLyWmwDH6HWCnjZ/aIQRBTIQ05uVeEoYxSh6wOai7ss/KveoSNBbYz
gbdzoqI2Y8cgH2nbfgp3DSasaLZEdCSsIsK1u05CinE7k2qZ7KgKAUIcT/cR/grk
C6VwsnDU0OUCideXcQ8WeHutqvgZH1JgKDbznoIzeQHJD238GEu+eKhRHcz8/jeG
94zkcgJOz3KbZGYMiTh277Fvj9zzvZsbMBCedV1BTg3TqgvdX4bdkhf5cH+7NtWO
lrFj6UwAsGukBTAOxC0l/dnSmZhJ7Z1KmEWilro/gOrjtOxqRQutlIqG22TaqoPG
fYVN+en3Zwbt97kcgZDwqbuykNt64oZWc4XKCa3mprEGC3IbJTBFqglXmZ7l9ywG
EEUJYOlb2XrSuPWml39beWdKM8kzr1OjnlOm6+lpTRCBfo0wa9F8YZRhHPAkwKkX
XDeOGpWRj4ohOx0d2GWkyV5xyN14p2tQOCdOODmz80yUTgRpPVQUtOEhXQARAQAB
tCFBV1MgQ0xJIFRlYW0gPGF3cy1jbGlAYW1hem9uLmNvbT6JAlQEEwEIAD4CGwMF
CwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQT7Xbd/1cEYuAURraimMQrMRnJHXAUC
aGveYQUJDMpiLAAKCRCmMQrMRnJHXKBYD/9Ab0qQdGiO5hObchG8xh8Rpb4Mjyf6
0JrVo6m8GNjNj6BHkSc8fuTQJ/FaEhaQxj3pjZ3GXPrXjIIVChmICLlFuRXYzrXc
Pw0lniybypsZEVai5kO0tCNBCCFuMN9RsmmRG8mf7lC4FSTbUDmxG/QlYK+0IV/l
uJkzxWa+rySkdpm0JdqumjegNRgObdXHAQDWlubWQHWyZyIQ2B4U7AxqSpcdJp6I
S4Zds4wVLd1WE5pquYQ8vS2cNlDm4QNg8wTj58e3lKN47hXHMIb6CHxRnb947oJa
pg189LLPR5koh+EorNkA1wu5mAJtJvy5YMsppy2y/kIjp3lyY6AmPT1posgGk70Z
CmToEZ5rbd7ARExtlh76A0cabMDFlEHDIK8RNUOSRr7L64+KxOUegKBfQHb9dADY
qqiKqpCbKgvtWlds909Ms74JBgr2KwZCSY1HaOxnIr4CY43QRqAq5YHOay/mU+6w
hhmdF18vpyK0vfkvvGresWtSXbag7Hkt3XjaEw76BzxQH21EBDqU8WJVjHgU6ru+
DJTs+SxgJbaT3hb/vyjlw0lK+hFfhWKRwgOXH8vqducF95NRSUxtS4fpqxWVaw3Q
V2OWSjbne99A5EPEySzryFTKbMGwaTlAwMCwYevt4YT6eb7NmFhTx0Fis4TalUs+
j+c7Kg92pDx2uQ==
=OBAt
-----END PGP PUBLIC KEY BLOCK-----
```
Als Referenz finden Sie im Folgenden die Details des öffentlichen Schlüssels.
```
Key ID: A6310ACC4672
Type: RSA
Size: 4096/4096
Created: 2019-09-18
Expires: 2026-07-07
User ID: AWS CLI Team
Key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
1. Importieren Sie den AWS CLI öffentlichen Schlüssel mit dem folgenden Befehl und ersetzen Sie ihn durch den Dateinamen des öffentlichen *public-key-file-name* Schlüssels, den Sie erstellt haben.
```
$ gpg --import public-key-file-name
gpg: /home/username/.gnupg/trustdb.gpg: trustdb created
gpg: key A6310ACC4672475C: public key "AWS CLI Team " imported
gpg: Total number processed: 1
gpg: imported: 1
```
1. [Laden Sie die AWS CLI Signaturdatei für das Paket herunter, das Sie unter /awscli.tar.gz.sig heruntergeladen haben. https://awscli.amazonaws.com](https://awscli.amazonaws.com/awscli.tar.gz.sig) Sie hat denselben Pfad und denselben Namen wie die Tarball-Datei, der sie entspricht, hat aber die Erweiterung `.sig`. Speichern Sie sie im gleichen Pfad wie die Tarball-Datei. Oder verwenden Sie den folgenden Befehlsblock:
```
$ curl awscliv2.sig https://awscli.amazonaws.com/ -o awscli.tar.gz.sig
```
1. Überprüfen Sie die Signatur und übergeben Sie sowohl den heruntergeladenen `.sig`- als auch den `.zip`-Dateinamen als Parameter an den `gpg`-Befehl.
```
$ gpg --verify awscliv2.sig awscli.tar.gz
```
Die Ausgabe sollte in etwa folgendermaßen aussehen:
```
gpg: Signature made Mon Nov 4 19:00:01 2019 PST
gpg: using RSA key FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
gpg: Good signature from "AWS CLI Team " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
**Wichtig**
Die Warnung in der Ausgabe wird erwartet und ist kein Hinweis auf ein Problem. Das liegt daran, dass zwischen Ihrem persönlichen PGP-Schlüssel (falls Sie einen haben) und dem PGP-Schlüssel keine Vertrauenskette besteht. AWS CLI Weitere Informationen finden Sie unter [Web of trust](https://wikipedia.org/wiki/Web_of_trust) (Netz des Vertrauens).
1. Sie haben eine Umgebung, in der von [GNU Autotools](https://www.gnu.org/software/automake/faq/autotools-faq.html) generierte Dateien wie `configure` und `Makefile` ausgeführt werden können. Diese Dateien sind auf POSIX-Plattformen weitgehend portabel.
------
#### [ Linux and macOS ]
Wenn Autotools in Ihrer Umgebung noch nicht installiert sind oder Sie sie aktualisieren müssen, folgen Sie den Installationsanweisungen unter [Wie installiere ich die Autotools (als Benutzer)?](https://www.gnu.org/software/automake/faq/autotools-faq.html#How-do-I-install-the-Autotools-_0028as-user_0029_003f) oder [Grundinstallation](https://www.gnu.org/savannah-checkouts/gnu/automake/manual/automake.html#Basic-Installation) in der *GNU-Dokumentation*.
------
#### [ Windows PowerShell ]
**Warnung**
Wir empfehlen, dass Sie in einer Windows-Umgebung die vordefinierten Installationsprogramme verwenden. Anweisungen zur Installation der vordefinierten Installationsprogramme finden Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](getting-started-install.md)
Da Windows nicht mit einer POSIX-kompatiblen Shell geliefert wird, müssen Sie zusätzliche Software installieren, um sie von der Quelle aus zu installieren. AWS CLI [MSYS2](https://www.msys2.org/)stellt eine Sammlung von Tools und Bibliotheken zur Verfügung, die beim Erstellen und Installieren von Windows-Software helfen, insbesondere für das POSIX-basierte Scripting, das Autotools verwendet.
1. Installieren. MSYS2 Informationen zur Installation und Verwendung MSYS2 finden Sie in den [Installations- und Nutzungsanweisungen](https://www.msys2.org/) in der *MSYS2 Dokumentation*.
1. Öffnen Sie das MSYS2 Terminal und installieren Sie Autotools mit dem folgenden Befehl.
```
$ pacman -S autotools
```
**Anmerkung**
Wenn Sie die Codebeispiele configure, build und install in diesem Handbuch für Windows verwenden, `C:\msys64\usr\bin\bash` wird der MSYS2 Standardinstallationspfad von angenommen. Wenn Sie MSYS2 inside of aufrufen, verwenden PowerShell Sie das folgende Format, wobei der Befehl bash in Anführungszeichen steht:
```
PS C:\> C:\msys64\usr\bin\bash -lc "command example"
```
Das folgende Befehlsbeispiel ruft den `./configure`-Befehl auf.
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure"
```
------
1. Python 3.8-Interpreter oder höher ist installiert. Die erforderliche Python-Mindestversion folgt den gleichen Zeitplänen wie die offizielle [Python-Supportrichtlinie für AWS SDKs und Tools](https://aws.amazon.com/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/). Ein Interpreter wird erst 6 Monate nach seinem Datum unterstützt. end-of-support
1. **(Optional)** Installieren Sie alle Build- und Laufzeit-Python-Bibliotheksabhängigkeiten der AWS CLI. Der `./configure`-Befehl informiert Sie darüber, ob Ihnen Abhängigkeiten fehlen und wie Sie diese installieren.
Sie können diese Abhängigkeiten über die Konfiguration automatisch installieren und verwenden. Weitere Informationen finden Sie unter [Herunterladen von Abhängigkeiten](#source-getting-started-install-config-dependencies).
## Schritt 2: Konfiguration der AWS CLI Quellinstallation
Die Konfiguration für den Aufbau und die Installation von AWS CLI wird mithilfe des `configure` Skripts angegeben. Für die Dokumentation aller Konfigurationsoptionen führen Sie das `configure`-Skript mit der `--help`-Option aus:
------
#### [ Linux and macOS ]
```
$ ./configure --help
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure --help"
```
------
**Topics**
+ [Installationsspeicherort](#source-getting-started-install-config-location)
+ [Python-Interpreter](#source-getting-started-install-config-interpreter)
+ [Herunterladen von Abhängigkeiten](#source-getting-started-install-config-dependencies)
+ [Installationstyp](#source-getting-started-install-config-type)
### Installationsspeicherort
Die Quellinstallation von AWS CLI verwendet zwei konfigurierbare Verzeichnisse zur Installation von AWS CLI:
+ `libdir`- Übergeordnetes Verzeichnis, in dem das installiert AWS CLI werden soll. Der Pfad zur AWS CLI Installation ist`/aws-cli`. Der `libdir`-Standardwert für Linux und macOS ist `/usr/local/lib` zur Markierung des Standardinstallationsverzeichnisses `/usr/local/lib/aws-cli`.
+ `bindir`- Verzeichnis, in dem die AWS CLI ausführbaren Dateien installiert sind. Der Standardspeicherort ist `/usr/local/bin`.
Die folgenden `configure`-Optionen steuern die verwendeten Verzeichnisse:
+ `--prefix` – Legt das Verzeichnispräfix fest, das für die Installation verwendet werden soll. Der Standardwert für Linux und macOS ist `/usr/local`.
+ `--libdir` – Legt den für die Installation der AWS CLI zu verwendenden `libdir` fest. Der Standardwert ist `/lib`. Wenn `--libdir` und `--prefix` nicht angegeben sind, ist die Standardeinstellung für Linux und macOS `/usr/local/lib/`.
+ `--bindir`- Legt fest, welches für `bindir` die Installation der AWS CLI `aws` und `aws_completer` der ausführbaren Dateien verwendet werden soll. Der Standardwert ist `/bin`. Wenn `bindir` und `--prefix` nicht angegeben sind, ist die Standardeinstellung für Linux und macOS `/usr/local/bin/`.
------
#### [ Linux and macOS ]
Im folgenden Befehlsbeispiel wird die Option `--prefix` verwendet, um eine lokale Benutzerinstallation der AWS CLI durchzuführen. Dieser Befehl installiert das AWS CLI In `$HOME/.local/lib/aws-cli` und die ausführbaren Dateien in: `$HOME/.local/bin`
```
$ ./configure --prefix=$HOME/.local
```
Im folgenden Befehlsbeispiel wird die Option `--libdir` verwendet, um die AWS CLI als Zusatzanwendung im `/opt`-Verzeichnis zu installieren. Dieser Befehl installiert die Dateien AWS CLI at `/opt/aws-cli` und die ausführbaren Dateien an ihrem Standardspeicherort von. `/usr/local/bin`
```
$ ./configure --libdir=/opt
```
------
#### [ Windows PowerShell ]
Im folgenden Befehlsbeispiel wird die Option `--prefix` verwendet, um eine lokale Benutzerinstallation der AWS CLI durchzuführen. Dieser Befehl installiert die Dateien AWS CLI in `$HOME/.local/lib/aws-cli` und die ausführbaren Dateien in: `$HOME/.local/bin`
```
$ C:\msys64\usr\bin\bash -lc "./configure --prefix='C:\Program Files\AWSCLI'"
```
Im folgenden Befehlsbeispiel wird die Option `--libdir` verwendet, um die AWS CLI als Zusatzanwendung im `/opt`-Verzeichnis zu installieren. Dieser Befehl installiert das AWS CLI at. `C:\Program Files\AWSCLI\opt\aws-cli`
------
### Python-Interpreter
**Anmerkung**
Es wird dringend empfohlen, den Python-Interpreter bei der Installation für Windows anzugeben.
Das `./configure` Skript wählt automatisch einen installierten Interpreter für Python 3.8 oder höher aus, der beim Erstellen und Ausführen des Makros Using the [https://www.gnu.org/software/automake/manual/html_node/Python.html](https://www.gnu.org/software/automake/manual/html_node/Python.html)Autoconf AWS CLI verwendet werden soll.
Der zu verwendende Python-Interpreter kann beim Ausführen des `configure`-Skripts mithilfe der `PYTHON`-Umgebungsvariablen explizit festgelegt werden:
------
#### [ Linux and macOS ]
```
$ PYTHON=/path/to/python ./configure
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "PYTHON='C:\path\to\python' ./configure"
```
------
### Herunterladen von Abhängigkeiten
Standardmäßig ist es erforderlich, dass alle Build- und Laufzeitabhängigkeiten von bereits auf dem System installiert AWS CLI sind. Dies schließt alle Abhängigkeiten der Python-Bibliothek ein. Alle Abhängigkeiten werden überprüft, wenn das `configure`-Skript ausgeführt wird, und wenn dem System irgendwelche Python-Abhängigkeiten fehlen, meldet das `configure`-Skript einen Fehler.
Im folgenden Codebeispiel treten Fehler auf, wenn Ihrem System Abhängigkeiten fehlen:
------
#### [ Linux and macOS ]
```
$ ./configure
checking for a Python interpreter with version >= 3.8... python
checking for python... /Users/username/.envs/env3.11/bin/python
checking for python version... 3.11
checking for python platform... darwin
checking for GNU default python prefix... ${prefix}
checking for GNU default python exec_prefix... ${exec_prefix}
checking for python script directory (pythondir)... ${PYTHON_PREFIX}/lib/python3.11/site-packages
checking for python extension module directory (pyexecdir)... ${PYTHON_EXEC_PREFIX}/lib/python3.11/site-packages
checking for --with-install-type... system-sandbox
checking for --with-download-deps... Traceback (most recent call last):
File "", line 198, in _run_module_as_main
File "", line 88, in _run_code
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 125, in
main()
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 121, in main
parsed_args.func(parsed_args)
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 49, in validate
validate_env(parsed_args.artifact)
File "/Users/username/aws-code/aws-cli/./backends/build_system/validate_env.py", line 68, in validate_env
raise UnmetDependenciesException(unmet_deps, in_venv)
validate_env.UnmetDependenciesException: Environment requires following Python dependencies:
awscrt (required: ('>=0.12.4', '<0.17.0')) (version installed: None)
We recommend using --with-download-deps flag to automatically create a virtualenv and download the dependencies.
If you want to manage the dependencies yourself instead, run the following pip command:
/Users/username/.envs/env3.11/bin/python -m pip install --prefer-binary 'awscrt>=0.12.4,<0.17.0'
configure: error: "Python dependencies not met."
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure"
checking for a Python interpreter with version >= 3.8... python
checking for python... /Users/username/.envs/env3.11/bin/python
checking for python version... 3.11
checking for python platform... darwin
checking for GNU default python prefix... ${prefix}
checking for GNU default python exec_prefix... ${exec_prefix}
checking for python script directory (pythondir)... ${PYTHON_PREFIX}/lib/python3.11/site-packages
checking for python extension module directory (pyexecdir)... ${PYTHON_EXEC_PREFIX}/lib/python3.11/site-packages
checking for --with-install-type... system-sandbox
checking for --with-download-deps... Traceback (most recent call last):
File "", line 198, in _run_module_as_main
File "", line 88, in _run_code
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 125, in
main()
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 121, in main
parsed_args.func(parsed_args)
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 49, in validate
validate_env(parsed_args.artifact)
File "/Users/username/aws-code/aws-cli/./backends/build_system/validate_env.py", line 68, in validate_env
raise UnmetDependenciesException(unmet_deps, in_venv)
validate_env.UnmetDependenciesException: Environment requires following Python dependencies:
awscrt (required: ('>=0.12.4', '<0.17.0')) (version installed: None)
We recommend using --with-download-deps flag to automatically create a virtualenv and download the dependencies.
If you want to manage the dependencies yourself instead, run the following pip command:
/Users/username/.envs/env3.11/bin/python -m pip install --prefer-binary 'awscrt>=0.12.4,<0.17.0'
configure: error: "Python dependencies not met."
```
------
Verwenden Sie die Option `--with-download-deps`, um die erforderlichen Python-Abhängigkeiten automatisch zu installieren. Wenn Sie dieses Flag verwenden, führt der Build-Prozess Folgendes aus:
+ Überspringen der Abhängigkeitsprüfung der Python-Bibliothek.
+ Konfigurieren der Einstellungen, um alle erforderlichen Python-Abhängigkeiten herunterzuladen und **nur** die heruntergeladenen Abhängigkeiten zu verwenden, um die AWS CLI während des `make`-Builds zu erstellen.
Das folgende Konfigurationsbefehlsbeispiel verwendet die Option `--with-download-deps` zum Herunterladen und Verwenden der Python-Abhängigkeiten:
------
#### [ Linux and macOS ]
```
$ ./configure --with-download-deps
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure --with-download-deps"
```
------
### Installationstyp
Der Quellinstallationsprozess unterstützt die folgenden Installationstypen:
+ `system-sandbox`— **(Standard)** Erstellt eine isolierte virtuelle Python-Umgebung, installiert die AWS CLI in der virtuellen Umgebung und stellt Symlinks zur `aws` und `aws_completer` ausführbaren Datei in der virtuellen Umgebung her. Diese Installation von AWS CLI hängt für seine Laufzeit direkt vom ausgewählten Python-Interpreter ab.
Dies ist ein einfacher Installationsmechanismus, um das AWS CLI auf einem System zu installieren. Er folgt den bewährten Python-Methoden, indem die Installation in einer virtuellen Umgebung Sandboxing ausgeführt wird. Diese Installation ist für Kunden gedacht, die den AWS CLI Quellcode so reibungslos wie möglich installieren möchten, wobei die Installation an Ihre Python-Installation gekoppelt ist.
+ `portable-exe`- Friert das AWS CLI in eine eigenständige ausführbare Datei ein, die an Umgebungen mit ähnlichen Architekturen verteilt werden kann. Dies ist derselbe Prozess, der verwendet wird, um die offiziellen vordefinierten ausführbaren Dateien der AWS CLI zu generieren. Das `portable-exe` friert eine Kopie des Python-Interpreters ein, der im `configure`-Schritt ausgewählt wurde, um ihn für die Laufzeit der AWS CLI zu verwenden. Dadurch kann sie auf andere Computer verschoben werden, die möglicherweise keinen Python-Interpreter haben.
Diese Art von Builds ist nützlich, da Sie damit sicherstellen können, dass Ihre AWS CLI -Installation nicht an die in der Umgebung installierte Python-Version gekoppelt ist und Sie einen Build auf ein anderes System verteilen können, auf dem Python möglicherweise noch nicht installiert ist. Auf diese Weise können Sie die Abhängigkeiten und die Sicherheit der von Ihnen verwendeten AWS CLI ausführbaren Dateien kontrollieren.
Um den Installationstyp zu konfigurieren, verwenden Sie die Option `--with-install-type` und geben Sie einen Wert von `portable-exe` oder `system-sandbox` an.
Der folgende `./configure`-Befehl gibt den Wert `portable-exe` an:
------
#### [ Linux and macOS ]
```
$ ./configure --with-install-type=portable-exe
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure --with-install-type=portable-exe"
```
------
## Schritt 3: Aufbau des AWS CLI
Verwenden Sie den `make` Befehl, um das AWS CLI mit Ihren Konfigurationseinstellungen zu erstellen:
------
#### [ Linux and macOS ]
```
$ make
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "make"
```
------
**Anmerkung**
Eine virtuelle Umgebung wird im Build-Verzeichnis mithilfe des [https://docs.python.org/3/library/venv.html](https://docs.python.org/3/library/venv.html)-Python-Moduls erstellt. Die virtuelle Umgebung wird mit einer [Version von Pip gebootet, die in der Python-Standardbibliothek angeboten wird](https://docs.python.org/3/library/ensurepip.html).
Kopieren der Abhängigkeiten der Python-Bibliothek. Je nachdem, ob das `--with-download-deps`-Flag im `configure`-Befehl angegeben ist, führt dieser Schritt eine der folgenden Aktionen aus:
Der `--with-download-deps` **wird** angegeben. Python-Abhängigkeiten sind Pip-installiert. Dies beinhaltet `wheel`, `setuptools` und alle AWS CLI -Laufzeitabhängigkeiten. Wenn Sie das `portable-exe` erstellen, wird `pyinstaller` installiert. Diese Anforderungen sind alle in den aus [https://github.com/jazzband/pip-tools](https://github.com/jazzband/pip-tools) generierten Sperrdateien spezifiziert.
Das `--with-download-deps` wird **nicht** angegeben. Python-Bibliotheken aus dem Site-Paket des Python-Interpreters sowie alle Skripte (z. B. `pyinstaller`) werden in die virtuelle Umgebung kopiert, die für den Build verwendet wird.
Wird `pip install` direkt auf der AWS CLI Codebasis ausgeführt, um einen Offline-Build im Baum durchzuführen und die virtuelle Umgebung AWS CLI in der Build-Umgebung zu installieren. [Diese Installation verwendet die Pip-Flags [-- no-build-isolation ](https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-build-isolation), [--use-feature= in-tree-build ](https://pip.pypa.io/en/stable/cli/pip_install/#local-project-installs), -- und. no-cache-dir [https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-index](https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-index)](https://pip.pypa.io/en/stable/cli/pip_install/#caching)
**(Optional)** Wenn das `portable-exe` im `configure`-Befehl auf `--install-type` gesetzt ist, wird eine eigenständige ausführbare Datei mithilfe von [https://www.pyinstaller.org/](https://www.pyinstaller.org/) erstellt.
## Schritt 4: Installation des AWS CLI
`make install`Mit dem Befehl wird Ihr Build AWS CLI an der konfigurierten Stelle auf dem System installiert.
------
#### [ Linux and macOS ]
Das folgende Befehlsbeispiel installiert das AWS CLI unter Verwendung Ihrer Konfiguration und Build-Einstellungen:
```
$ make install
```
------
#### [ Windows PowerShell ]
Das folgende Befehlsbeispiel installiert das AWS CLI unter Verwendung Ihrer Konfiguration und Build-Einstellungen und fügt dann eine Umgebungsvariable mit dem Pfad für hinzu AWS CLI:
```
PS C:\> C:\msys64\usr\bin\bash -lc " make install "
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
```
------
Die `make install`-Regel unterstützt die [https://www.gnu.org/software/make/manual/html_node/DESTDIR.html#DESTDIR](https://www.gnu.org/software/make/manual/html_node/DESTDIR.html#DESTDIR)-Variable. Wenn angegeben, setzt diese Variable den angegebenen Pfad dem bereits konfigurierten Installationspfad bei der Installation der AWS CLI voran. Standardmäßig ist für diese Variable kein Wert festgelegt.
------
#### [ Linux and macOS ]
Im folgenden Codebeispiel wird ein `--prefix=/usr/local`-Flag für die Konfiguration eines Installationsverzeichnisses verwendet. Anschließend wird dieses Ziel mithilfe von `DESTDIR=/tmp/stage` für den `make install`-Befehl geändert. Diese Befehle führen dazu, AWS CLI dass das unter installiert wird `/tmp/stage/usr/local/lib/aws-cli` und seine ausführbaren Dateien sich unter befinden. `/tmp/stage/usr/local/bin`
```
$ ./configure --prefix=/usr/local
$ make
$ make DESTDIR=/tmp/stage install
```
------
#### [ Windows PowerShell ]
Im folgenden Codebeispiel wird ein `--prefix=\awscli`-Flag für die Konfiguration eines Installationsverzeichnisses verwendet. Anschließend wird dieses Ziel mithilfe von `DESTDIR=C:\Program Files` für den `make install`-Befehl geändert. Diese Befehle führen dazu, AWS CLI dass das unter installiert wird. `C:\Program Files\awscli`
```
$ ./configure --prefix=\awscli
$ make
$ make DESTDIR='C:\Program Files' install
```
------
**Anmerkung**
Verschieben einer der folgenden Dateien in das konfigurierte Installationsverzeichnis:
Wenn der Installationstyp `system-sandbox` ist, wird Ihre erstellte virtuelle Umgebung verschoben.
Wenn der Installationstyp `portable-exe` ist, wird Ihre erstellte eigenständige ausführbare Datei verschoben.
Erzeugt Symlinks sowohl für die ausführbaren `aws`- als auch für die `aws_completer`-Dateien in Ihrem konfigurierten Bin-Verzeichnis.
## Schritt 5: Überprüfen der Installation AWS CLI
Bestätigen Sie die AWS CLI erfolgreiche Installation mit dem folgenden Befehl:
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Wenn der `aws`-Befehl nicht erkannt wird, müssen Sie möglicherweise Ihr Terminal neu starten, damit die neuen Symlinks aktualisiert werden. Wenn Sie nach der Installation oder Deinstallation von auf weitere Probleme stoßen AWS CLI, finden Sie unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) Allgemeine Schritte zur Problembehebung
## Workflow-Beispiele
Dieser Abschnitt enthält einige grundlegende Workflow-Beispiele für die Installation aus der Quelle.
### Grundlegende Linux- und macOS-Installation
Das folgende Beispiel zeigt einen grundlegenden Installationsablauf, bei dem der im Standardverzeichnis von `/usr/local/lib/aws-cli` installiert AWS CLI wird.
```
$ cd path/to/cli/respository/
$ ./configure
$ make
$ make install
```
### Automatisierte Windows-Installation
**Anmerkung**
Sie müssen ihn PowerShell als Administrator ausführen, um diesen Workflow verwenden zu können.
MSYS2 kann automatisiert in einer CI-Umgebung verwendet werden, siehe [ MSYS2 In CI verwenden](https://www.msys2.org/docs/ci/) in der *MSYS2 Dokumentation*.
------
#### [ Downloaded Tarball ]
Laden Sie die Datei `awscli.tar.gz` herunter und installieren Sie die AWS CLI. Ersetzen Sie die folgenden Pfade, wenn Sie die folgenden Befehle verwenden:
+ `C:\msys64\usr\bin\bash`mit der Position Ihres MSYS2 Pfads.
+ `.\awscli-2.x.x\` durch den Namen des entpackten `awscli.tar.gz`-Ordners.
+ `PYTHON='C:\path\to\python.exe'` durch Ihren lokalen Python-Pfad.
Das folgende Codebeispiel automatisiert das Erstellen und Installieren AWS CLI von PowerShell from using und gibt an MSYS2, welche lokale Python-Installation verwendet werden soll:
```
PS C:\> curl "https://awscli.amazonaws.com/awscli.tar.gz" -o "awscliv2.zip" # Download the awscli.tar.gz file in the current working directory
PS C:\> tar -xvzf .\awscli.tar.gz # Extract awscli.tar.gz file
PS C:\> cd .\awscli-2.x.x\ # Navigate to the root of the extracted files
PS C:\> $env:CHERE_INVOKING = 'yes' # Preserve the current working directory
PS C:\> C:\msys64\usr\bin\bash -lc " PYTHON='C:\path\to\python.exe' ./configure --prefix='C:\Program Files\AWSCLI' --with-download-deps "
PS C:\> C:\msys64\usr\bin\bash -lc "make"
PS C:\> C:\msys64\usr\bin\bash -lc "make install"
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
PS C:\> aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 source-sandbox/AMD64
```
------
#### [ GitHub Repository ]
Laden Sie die Datei `awscli.tar.gz` herunter und installieren Sie die AWS CLI. Ersetzen Sie die folgenden Pfade, wenn Sie die folgenden Befehle verwenden:
+ `C:\msys64\usr\bin\bash`mit der Position Ihres MSYS2 Pfads.
+ `C:path\to\cli\repository\`mit dem Pfad zu Ihrem geklonten [AWS CLI Repository](https://github.com/aws/aws-cli) von *GitHub*. *Weitere Informationen finden Sie in den Dokumenten unter [Fork a repo](https://docs.github.com/en/get-started/quickstart/fork-a-repo) GitHub *
+ `PYTHON='C:\path\to\python.exe'` durch Ihren lokalen Python-Pfad.
Das folgende Codebeispiel automatisiert das Erstellen und Installieren AWS CLI von PowerShell from using und gibt an MSYS2, welche lokale Python-Installation verwendet werden soll:
```
PS C:\> cd C:path\to\cli\repository\
PS C:\> $env:CHERE_INVOKING = 'yes' # Preserve the current working directory
PS C:\> C:\msys64\usr\bin\bash -lc " PYTHON='C:\path\to\python.exe' ./configure --prefix='C:\Program Files\AWSCLI' --with-download-deps "
PS C:\> C:\msys64\usr\bin\bash -lc "make"
PS C:\> C:\msys64\usr\bin\bash -lc "make install"
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
PS C:\> aws --version
```
------
### Alpine Linux-Container
Im Folgenden finden Sie ein Beispiel für eine Docker-Datei, die verwendet werden kann, um eine funktionierende Installation der AWS CLI in einem Alpine-Linux-Container als [Alternative zu vordefinierten Binärdateien für Alpine](https://github.com/aws/aws-cli/issues/4685) zu erhalten. Wenn Sie dieses Beispiel verwenden, *AWSCLI\$1VERSION* ersetzen Sie es durch die gewünschte AWS CLI Versionsnummer:
```
1. FROM python:3.8-alpine AS builder
2.
3. ENV AWSCLI_VERSION=2.10.1
4.
5. RUN apk add --no-cache \
6. curl \
7. make \
8. cmake \
9. gcc \
10. g++ \
11. libc-dev \
12. libffi-dev \
13. openssl-dev \
14. && curl https://awscli.amazonaws.com/awscli-${AWSCLI_VERSION}.tar.gz | tar -xz \
15. && cd awscli-${AWSCLI_VERSION} \
16. && ./configure --prefix=/opt/aws-cli/ --with-download-deps \
17. && make \
18. && make install
19.
20. FROM python:3.8-alpine
21.
22. RUN apk --no-cache add groff
23.
24. COPY --from=builder /opt/aws-cli/ /opt/aws-cli/
25.
26. ENTRYPOINT ["/opt/aws-cli/bin/aws"]
```
Dieses Image wird aus einem Container erstellt und AWS CLI dann aufgerufen, der dem Container ähnelt, der auf Amazon Linux 2 erstellt wurde:
```
$ docker build --tag awscli-alpine .
$ docker run --rm -it awscli-alpine --version
aws-cli/2.2.1 Python/3.8.11 Linux/5.10.25-linuxkit source-sandbox/x86_64.alpine.3 prompt/off
```
Die endgültige Größe dieses Images ist kleiner als die Größe des offiziellen AWS CLI Docker-Images. Informationen zum offiziellen Docker-Image finden Sie unter [Ausführen der offiziellen Amazon ECR Public- oder Docker-Images für AWS CLI](getting-started-docker.md).
## Behebung von AWS CLI Installations- und Deinstallationsfehlern
Schritte zur Behebung von Installationsfehlern finden Sie unter [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md) Allgemeine Schritte zur Problembehandlung. Die wichtigsten Maßnahmen zur Fehlerbehebung finden Sie unter [Fehler aufgrund eines nicht gefundenen Befehls](cli-chap-troubleshooting.md#tshoot-install-not-found), [Der Befehl „`aws --version`“ gibt eine andere als die installierte Version zurück](cli-chap-troubleshooting.md#tshoot-install-wrong-version) und [Der Befehl "`aws --version`" gibt nach der Deinstallation von eine Version zurück AWS CLI](cli-chap-troubleshooting.md#tshoot-uninstall-1).
Suchen Sie bei Problemen, die nicht in den Anleitungen zur Fehlerbehebung behandelt werden, nach den Problemen mit der `source-distribution` Bezeichnung im [AWS CLI Repository](https://github.com/aws/aws-cli/labels/source-distribution) auf *GitHub*. Wenn keine bestehenden Probleme Ihre Fehler abdecken, [erstellen Sie eine neue Ausgabe](https://github.com/aws/aws-cli/issues/new?assignees=&labels=source-distribution%2Cneeds-triage&template=source-distribution.yml&title=%28short+issue+description%29), um Hilfe von den AWS CLI Betreuern zu erhalten.
## Nächste Schritte
Nach der Installation von AWS CLI sollten Sie eine durchführen. [Einrichtung der AWS CLI](getting-started-quickstart.md)
# Ausführen der offiziellen Amazon ECR Public- oder Docker-Images für AWS CLI
In diesem Thema wird beschrieben, wie AWS CLI Version 2 auf Docker mit dem offiziellen Amazon Elastic Container Registry Public (Amazon ECR Public) oder dem Docker Hub-Image ausgeführt, Versionskontrolle und Konfiguration durchgeführt wird. Weitere Informationen zur Verwendung von Docker finden Sie in der [Dokumentation von Docker](https://docs.docker.com/).
Offizielle Images bieten Isolierung, Portabilität und Sicherheit, die AWS direkt unterstützt und verwaltet wird. Auf diese Weise können Sie AWS CLI Version 2 in einer containerbasierten Umgebung verwenden, ohne die Installation selbst verwalten zu müssen.
**Topics**
+ [Voraussetzungen](#cliv2-docker-prereq)
+ [Entscheidung zwischen Amazon ECR Public und Docker Hub](#cliv2-docker-versus)
+ [Führen Sie die offiziellen Images der AWS CLI Version 2 aus](#cliv2-docker-install)
+ [Hinweise zu Schnittstellen und Abwärtskompatibilität der offiziellen Images](#cliv2-docker-install-notes)
+ [Verwenden bestimmter Versionen und Tags](#cliv2-docker-upgrade)
+ [Aktualisieren auf das neueste offizielle Image](#cliv2-docker-update)
+ [Freigeben von Hostdateien, Anmeldeinformationen, Umgebungsvariablen und Konfiguration](#cliv2-docker-share-files)
+ [Verkürzen des Docker-Ausführungsbefehls](#cliv2-docker-aliases)
## Voraussetzungen
Sie müssen Docker installiert haben. Installationsanweisungen finden Sie auf der [Docker-Website](https://docs.docker.com/install/).
Um Ihre Installation von Docker zu überprüfen, führen Sie den folgenden Befehl aus und stellen Sie sicher, dass eine Ausgabe vorhanden ist.
```
$ docker --version
Docker version 19.03.1
```
## Entscheidung zwischen Amazon ECR Public und Docker Hub
Wir empfehlen die Verwendung von Amazon ECR Public über Docker Hub für AWS CLI Images. Beim Docker Hub gilt eine strengere Ratenbegrenzung für öffentliche Verbraucher, wodurch es zu Drosselungsproblemen kommen kann. Darüber hinaus repliziert Amazon ECR Public Images in mehr als einer Region, um eine hohe Verfügbarkeit zu gewährleisten und Probleme bezüglich des Ausfalls einer Region zu bewältigen.
Weitere Informationen über die Docker-Hub-Ratenbegrenzung finden Sie unter [Understanding Docker Hub Rate Limiting](https://www.docker.com/increase-rate-limits/) auf der *Docker*-Website.
## Führen Sie die offiziellen Images der AWS CLI Version 2 aus
Wenn Sie den `docker run`-Befehl zum ersten Mal verwenden, wird das neueste Image auf Ihren Computer heruntergeladen. Jede nachfolgende Verwendung des `docker run`-Befehls wird von Ihrer lokalen Kopie ausgeführt.
Verwenden Sie den `docker run` Befehl, um die Docker-Images der AWS CLI Version 2 auszuführen.
------
#### [ Amazon ECR Public ]
[Das offizielle Amazon ECR Public-Image der AWS CLI Version 2 wird auf Amazon ECR Public im `aws-cli/aws-cli` Repository gehostet.](https://gallery.ecr.aws/aws-cli/aws-cli)
```
$ docker run --rm -it public.ecr.aws/aws-cli/aws-cli command
```
------
#### [ Docker Hub ]
Das offizielle Docker-Image der AWS CLI Version 2 wird auf Docker Hub im Repository gehostet. `amazon/aws-cli`
```
$ docker run --rm -it amazon/aws-cli command
```
------
So funktioniert der Befehl:
+ `docker run --rm -it repository/name` – Das Äquivalent zur ausführbaren Datei `aws`. Jedes Mal, wenn Sie diesen Befehl ausführen, erstellt Docker einen Container Ihres heruntergeladenen Images und führt Ihren `aws`-Befehl aus. Standardmäßig verwendet das Image die neueste Version der AWS CLI Version 2.
Um beispielsweise den `aws --version`-Befehl in Docker aufzurufen, führen Sie Folgendes aus.
------
#### [ Amazon ECR Public ]
```
$ docker run --rm -it public.ecr.aws/aws-cli/aws-cli --version
aws-cli/2.27.41 Python/3.7.3 Linux/4.9.184-linuxkit botocore/2.4.5dev10
```
------
#### [ Docker Hub ]
```
$ docker run --rm -it amazon/aws-cli --version
aws-cli/2.27.41 Python/3.7.3 Linux/4.9.184-linuxkit botocore/2.4.5dev10
```
------
+ `--rm` – Gibt an, dass der Container nach dem Beenden des Befehls bereinigt wird.
+ `-it` – Gibt an, ein Pseudo-TTY mit `stdin` zu öffnen. Auf diese Weise können Sie Eingaben für AWS CLI Version 2 bereitstellen, während sie in einem Container ausgeführt wird, z. B. mithilfe der `aws help` Befehle `aws configure` und. Bei der Auswahl, ob `-it` weggelassen werden soll, ist Folgendes zu beachten:
+ Wenn Sie Skripte ausführen, ist `-it` nicht erforderlich.
+ Wenn bei Ihren Skripts Fehler auftreten, lassen sich diese eventuell beheben, indem Sie `-it` in Ihrem Docker-Aufruf weglassen.
+ Wenn Sie versuchen, die Ausgabe zu leiten, kann `-it` Fehler verursachen und das Weglassen von `-it` aus Ihrem Docker-Aufruf kann dieses Problem eventuell beheben. Wenn Sie das `-it`-Flag behalten, aber dennoch die Ausgabe leiten möchten, sollte das Deaktivieren des [clientseitigen Pagers](cli-usage-pagination.md#cli-usage-pagination-clientside), den die AWS CLI standardmäßig verwendet, das Problem lösen.
Weitere Informationen zum `docker run`-Befehl finden Sie im [Docker-Referenzhandbuch](https://docs.docker.com/engine/reference/run/).
## Hinweise zu Schnittstellen und Abwärtskompatibilität der offiziellen Images
+ Das einzige Tool, das auf dem Image unterstützt wird, ist das AWS CLI. Nur die ausführbare Datei `aws` sollte jemals direkt ausgeführt werden. Obwohl `less` sie beispielsweise explizit auf dem Image installiert `groff` sind, sollten sie nicht direkt außerhalb eines AWS CLI Befehls ausgeführt werden.
+ Das `/aws`-Arbeitsverzeichnis wird vom Benutzer gesteuert. Das Abbild schreibt nicht in dieses Verzeichnis, es sei denn, der Benutzer weist ihn dazu an, einen AWS CLI Befehl auszuführen.
+ Es gibt keine Abwärtskompatibilitätsgarantien, wenn Sie sich auf das neueste Tag verlassen. Um Abwärtskompatibilität zu gewährleisten, müssen Sie an ein bestimmtes Tag `` anheften, da diese Tags unveränderlich sind; sie werden nur einmal übertragen.
## Verwenden bestimmter Versionen und Tags
Das offizielle Image der AWS CLI Version 2 hat mehrere Versionen, die Sie verwenden können, beginnend mit Version`2.0.6`. Um eine bestimmte Version der AWS CLI Version 2 auszuführen, hängen Sie das entsprechende Tag an Ihren `docker run` Befehl an. Wenn Sie den `docker run`-Befehl zum ersten Mal mit einem Tag verwenden, wird das neueste Image für dieses Tag auf Ihren Computer heruntergeladen. Jede nachfolgende Verwendung des `docker run`-Befehls mit diesem Tag wird von Ihrer lokalen Kopie ausgeführt.
Sie können zwei Arten von Tags verwenden:
+ `latest`— Definiert die neueste Version der AWS CLI Version 2 für das Image. Wir empfehlen Ihnen, das `latest` Tag zu verwenden, wenn Sie die neueste Version von AWS CLI Version 2 verwenden möchten. Es gibt jedoch keine Abwärtskompatibilitätsgarantien, wenn Sie sich auf dieses Tag verlassen. Das `latest`-Tag wird standardmäßig im `docker run`-Befehl verwendet. Um das `latest`-Tag explizit zu verwenden, fügen Sie das Tag an den Container-Image-Namen an.
------
#### [ Amazon ECR Public ]
```
$ docker run --rm -it public.ecr.aws/aws-cli/aws-cli:latest command
```
------
#### [ Docker Hub ]
```
$ docker run --rm -it amazon/aws-cli:latest command
```
------
+ ``— Definiert eine spezifische Version der AWS CLI Version 2 für das Image. Wenn Sie planen, ein offizielles Image in der Produktion zu verwenden, empfehlen wir Ihnen, eine bestimmte Version der AWS CLI Version 2 zu verwenden, um die Abwärtskompatibilität sicherzustellen. Wenn Sie beispielsweise Version `2.0.6` ausführen möchten, fügen Sie die Version an den Container-Image-Namen an.
------
#### [ Amazon ECR Public ]
```
$ docker run --rm -it public.ecr.aws/aws-cli/aws-cli:2.0.6 command
```
------
#### [ Docker Hub ]
```
$ docker run --rm -it amazon/aws-cli:2.0.6 command
```
------
## Aktualisieren auf das neueste offizielle Image
Da das neueste Image nur bei der ersten Verwendung des `docker run`-Befehls auf Ihren Computer heruntergeladen wird, müssen Sie ein aktualisiertes Image manuell abrufen. Um manuell auf die neueste Version zu aktualisieren, empfehlen wir, das mit `latest` markierte Image abzurufen. Wenn Sie das Image abrufen, wird die neueste Version auf Ihren Computer heruntergeladen.
------
#### [ Amazon ECR Public ]
```
$ docker pull public.ecr.aws/aws-cli/aws-cli:latest
```
------
#### [ Docker Hub ]
```
$ docker pull amazon/aws-cli:latest
```
------
## Freigeben von Hostdateien, Anmeldeinformationen, Umgebungsvariablen und Konfiguration
Da AWS CLI Version 2 in einem Container ausgeführt wird, kann die CLI standardmäßig nicht auf das Host-Dateisystem zugreifen, das Konfiguration und Anmeldeinformationen enthält. Wenn Sie das Host-Dateisystem, die Anmeldeinformationen und die Konfiguration für den Container freigeben möchten, mounten Sie das `~/.aws`-Verzeichnis des Hostsystems in den Container unter `/root/.aws` mit dem an den `docker run`-Befehl angehängten `-v`-Flag. Dadurch kann die im Container ausgeführte AWS CLI Version 2 Hostdateiinformationen finden.
------
#### [ Amazon ECR Public ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli command
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli command
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli command
```
------
#### [ Docker Hub ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws amazon/aws-cli command
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws amazon/aws-cli command
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws amazon/aws-cli command
```
------
Weitere Informationen zum `-v`-Flag und zum Mounting finden Sie im [Docker-Referenzhandbuch](https://docs.docker.com/storage/volumes/).
**Anmerkung**
Weitere Informationen zu `config`- und `credentials`-Dateien finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
### Beispiel 1: Bereitstellen von Anmeldeinformationen und Konfiguration
In diesem Beispiel stellen wir Host-Anmeldeinformationen und -konfiguration durch Ausführung des `s3 ls`-Befehls bereit, um Ihre Buckets in der Amazon Simple Storage Service (Amazon S3) aufzulisten. In den folgenden Beispielen wird der Standardspeicherort für AWS CLI Anmeldeinformationen und Konfigurationsdateien verwendet. Um einen anderen Speicherort zu verwenden, ändern Sie den Dateipfad.
------
#### [ Amazon ECR Public ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli s3 ls
```
------
#### [ Docker Hub ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws amazon/aws-cli s3 ls
```
------
Sie können Umgebungsvariablen des Systems mithilfe des `-e`-Flag aufrufen. Um eine Umgebungsvariable zu verwenden, rufen Sie sie nach Namen auf.
------
#### [ Amazon ECR Public ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -e ENVVAR_NAME public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -e ENVVAR_NAME public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -e ENVVAR_NAME public.ecr.aws/aws-cli/aws-cli s3 ls
```
------
#### [ Docker Hub ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -e ENVVAR_NAME amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -e ENVVAR_NAME amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -e ENVVAR_NAME amazon/aws-cli s3 ls
```
------
### Beispiel 2: Download einer Amazon-S3-Datei auf Ihr Hostsystem
Bei einigen Befehlen der AWS CLI Version 2 können Sie Dateien vom Hostsystem im Container lesen oder Dateien vom Container auf das Hostsystem schreiben.
In diesem Beispiel laden wir das `S3`-Objekt `s3://aws-cli-docker-demo/hello` in Ihr lokales Dateisystem herunter, indem wir das aktuelle Arbeitsverzeichnis in das `/aws`-Verzeichnis des Containers mounten. Durch den Download des `hello`-Objekts in das `/aws`-Verzeichnis des Containers wird die Datei auch im aktuellen Arbeitsverzeichnis des Hostsystems gespeichert.
------
#### [ Amazon ECR Public ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws public.ecr.aws/aws-cli/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
download: s3://aws-cli-docker-demo/hello to ./hello
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws public.ecr.aws/aws-cli/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
download: s3://aws-cli-docker-demo/hello to ./hello
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws public.ecr.aws/aws-cli/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
```
------
#### [ Docker Hub ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws amazon/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
download: s3://aws-cli-docker-demo/hello to ./hello
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws amazon/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
download: s3://aws-cli-docker-demo/hello to ./hello
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws amazon/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
```
------
Führen Sie Folgendes aus, um sicherzustellen, dass die heruntergeladene Datei im lokalen Dateisystem vorhanden ist.
**Unter Linux und macOS**
```
$ cat hello
Hello from Docker!
```
**Windows PowerShell**
```
$ type hello
Hello from Docker!
```
### Beispiel 3: Verwenden Sie Ihre AWS\$1PROFILE Umgebungsvariable
Sie können Umgebungsvariablen des Systems mithilfe des `-e`-Flags aufrufen. Rufen Sie jede Umgebungsvariable auf, die Sie verwenden möchten. In diesem Beispiel geben wir Host-Anmeldeinformationen, Konfiguration und die *AWS\$1PROFILE* Umgebungsvariable an, wenn wir den `s3 ls` Befehl zum Auflisten Ihrer Buckets in Amazon Simple Storage Service (Amazon S3) ausführen.
------
#### [ Amazon ECR Public ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -e AWS_PROFILE public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -e AWS_PROFILE public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -e AWS_PROFILE public.ecr.aws/aws-cli/aws-cli s3 ls
```
------
#### [ Docker Hub ]
**Unter Linux und macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -e AWS_PROFILE amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows-Eingabeaufforderung**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -e AWS_PROFILE amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -e AWS_PROFILE amazon/aws-cli s3 ls
```
------
## Verkürzen des Docker-Ausführungsbefehls
Um den `docker run`-Befehl zu verkürzen, empfehlen wir, die Funktion Ihres Betriebssystems zum Erstellen eines [https://www.linux.com/topic/desktop/understanding-linux-links/](https://www.linux.com/topic/desktop/understanding-linux-links/) (symlink) oder [https://www.linux.com/topic/desktop/aliases-diy-shell-commands/](https://www.linux.com/topic/desktop/aliases-diy-shell-commands/) unter Linux und macOS oder [https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/doskey](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/doskey) unter Windows zu verwenden. Um den `aws`-Alias festzulegen, können Sie einen der folgenden Befehle ausführen.
+ Für einfachen Zugriff auf `aws`-Befehle führen Sie Folgendes aus.
------
#### [ Amazon ECR Public ]
**Unter Linux und macOS**
```
$ alias aws='docker run --rm -it public.ecr.aws/aws-cli/aws-cli'
```
**Windows-Eingabeaufforderung**
```
C:\> doskey aws=docker run --rm -it public.ecr.aws/aws-cli/aws-cli $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it public.ecr.aws/aws-cli/aws-cli $args}
Set-Alias -Name aws -Value AWSCLI
```
------
#### [ Docker Hub ]
**Unter Linux und macOS**
```
$ alias aws='docker run --rm -it amazon/aws-cli'
```
**Windows-Eingabeaufforderung**
```
C:\> doskey aws=docker run --rm -it amazon/aws-cli $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it amazon/aws-cli $args}
Set-Alias -Name aws -Value AWSCLI
```
------
+ Für den Zugriff auf das Host-Dateisystem und die Konfigurationseinstellungen bei Verwendung von `aws`-Befehlen führen Sie Folgendes aus.
------
#### [ Amazon ECR Public ]
**Unter Linux und macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws public.ecr.aws/aws-cli/aws-cli'
```
**Windows-Eingabeaufforderung**
```
C:\> doskey aws=docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws public.ecr.aws/aws-cli/aws-cli $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws public.ecr.aws/aws-cli/aws-cli $args}
Set-Alias -Name aws -Value AWSCLI
```
------
#### [ Docker Hub ]
**Unter Linux und macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws amazon/aws-cli'
```
**Windows-Eingabeaufforderung**
```
C:\> doskey aws=docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws amazon/aws-cli $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws amazon/aws-cli $args}
Set-Alias -Name aws -Value AWSCLI
```
------
+ Wenn Sie eine bestimmte Version zuweisen möchten, die in Ihrem `aws`-Alias verwendet werden soll, fügen Sie Ihr Versionstag an.
------
#### [ Amazon ECR Public ]
**Unter Linux und macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws public.ecr.aws/aws-cli/aws-cli:2.0.6'
```
**Windows-Eingabeaufforderung**
```
C:\> doskey aws=docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws public.ecr.aws/aws-cli/aws-cli:2.0.6 $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws public.ecr.aws/aws-cli/aws-cli:2.0.6 $args}
Set-Alias -Name aws -Value AWSCLI
```
------
#### [ Docker Hub ]
**Unter Linux und macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws amazon/aws-cli:2.0.6'
```
**Windows-Eingabeaufforderung**
```
C:\> doskey aws=docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws amazon/aws-cli:2.0.6 $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws amazon/aws-cli:2.0.6 $args}
Set-Alias -Name aws -Value AWSCLI
```
------
Nachdem Sie Ihren Alias festgelegt haben, können Sie AWS CLI Version 2 in einem Container ausführen, als ob sie auf Ihrem Hostsystem installiert wäre.
```
$ aws --version
aws-cli/2.27.41 Python/3.7.3 Linux/4.9.184-linuxkit botocore/2.4.5dev10
```
# Einrichtung der AWS CLI
In diesem Thema wird erklärt, wie Sie schnell die Grundeinstellungen konfigurieren können, mit denen AWS Command Line Interface (AWS CLI) interagiert AWS. Dazu gehören Ihre Sicherheitsanmeldeinformationen, das Standardausgabeformat und die AWS Standardregion.
**Topics**
+ [Erfassen Ihrer Anmeldeinformationen für den programmgesteuerten Zugriff](#getting-started-prereqs-keys)
+ [Einrichten einer neuen Konfiguration und Anmeldeinformationen](#getting-started-quickstart-new)
+ [Verwenden vorhandener Konfigurations- und Anmeldeinformationen](#getting-started-quickstart-existing)
## Erfassen Ihrer Anmeldeinformationen für den programmgesteuerten Zugriff
Sie benötigen programmatischen Zugriff, wenn Sie mit AWS außerhalb des AWS-Managementkonsole interagieren möchten. Wählen Sie für Anweisungen zur Authentifizierung und für Anmeldeinformationen eine der folgenden Optionen aus:
****
| Authentifizierungstyp | Zweck | Anleitungen |
| --- | --- | --- |
| AWS Anmeldeinformationen für die Management-Konsole | **(Empfohlen)** Verwenden Sie kurzfristige Anmeldeinformationen, indem Sie sich mit Ihren Konsolenanmeldedaten bei der AWS CLI anmelden. Wird empfohlen, wenn Sie Root, IAM-Benutzer oder einen Verbund mit IAM für AWS den Kontozugriff verwenden | [Melden Sie sich mit Konsolenanmeldedaten für die AWS lokale Entwicklung an](cli-configure-sign-in.md) |
| Kurzfristige Anmeldeinformationen für Unternehmensbenutzer von IAM Identity Center | Verwenden Sie kurzfristige Anmeldeinformationen für einen IAM Identity Center Workforce-Benutzer.Die bewährte Sicherheitsmethode ist die Verwendung AWS Organizations mit IAM Identity Center. Dabei werden kurzfristige Anmeldeinformationen mit einem Benutzerverzeichnis wie dem integrierten Verzeichnis von IAM Identity Center oder Active Directory kombiniert. | [Konfiguration der IAM Identity Center-Authentifizierung mit dem AWS CLI](cli-configure-sso.md) |
| Kurzfristige Anmeldeinformationen für IAM-Benutzer | Verwenden Sie kurzfristige Anmeldeinformationen für IAM-Benutzer, die sicherer als langfristige Anmeldeinformationen sind. Wenn Ihre Anmeldeinformationen kompromittiert werden, können sie nur für einen begrenzten Zeitraum verwendet werden, bevor sie ablaufen. | [Authentifizierung mit kurzfristigen Zugangsdaten für den AWS CLI](cli-authentication-short-term.md) |
| Benutzer von IAM oder IAM Identity Center auf einer Amazon-EC2-Instance | Verwenden Sie Metadaten einer Amazon-EC2-Instance, um mithilfe der Rolle, die der Amazon-EC2-Instance zugewiesen ist, temporäre Anmeldeinformationen abzufragen. | [Verwendung von Amazon EC2 EC2-Instance-Metadaten als Anmeldeinformationen in der AWS CLI](cli-configure-metadata.md) |
| Übernehmen von Rollen für Berechtigungen | Kombinieren Sie eine andere Anmeldeinformationsmethode und übernehmen Sie eine Rolle für den temporären Zugriff auf AWS-Services , auf die Ihr Benutzer möglicherweise keinen Zugriff hat. | [Verwenden einer IAM-Rolle in der AWS CLI](cli-configure-role.md) |
| Langfristige Anmeldeinformationen für IAM-Benutzer | (Nicht empfohlen) Verwenden Sie langfristige Anmeldeinformationen ohne Ablaufdatum. | [Authentifizierung mit IAM-Benutzeranmeldedaten für AWS CLI](cli-authentication-user.md) |
| Externe Speicherung für Unternehmensbenutzer von IAM oder IAM Identity Center | (Nicht empfohlen) Sie kombinieren mit einer anderen Anmeldeinformationsmethode, speichern die Anmeldeinformationswerte jedoch an einem Ort außerhalb der AWS CLI. Diese Methode ist nur so sicher wie der externe Ort, an dem die Anmeldeinformationen gespeichert werden. | [Beschaffung von Referenzen mit einem externen Prozess in der AWS CLI](cli-configure-sourcing-external.md) |
## Einrichten einer neuen Konfiguration und Anmeldeinformationen
Das AWS CLI speichert Ihre Konfiguration und Anmeldeinformationen in einem *Profil* (einer Sammlung von Einstellungen) in den Dateien `credentials` und`config`.
**Topics**
+ [Konfiguration mithilfe von Befehlen AWS CLI](#getting-started-quickstart-new-command)
+ [Manuelles Bearbeiten der Anmeldeinformationen und Konfigurationsdateien](#getting-started-quickstart-new-file)
In den folgenden Beispielen werden Beispielwerte für jede der Authentifizierungsmethoden verwendet. Ersetzen Sie die Beispielwerte durch Ihre eigenen Werte.
### Konfiguration mithilfe von Befehlen AWS CLI
Für den allgemeinen Gebrauch sind die Befehle `aws configure` oder `aws configure sso` in Ihrem bevorzugten Terminal die schnellste Möglichkeit, Ihre AWS CLI -Installation einzurichten. Je nach der von Ihnen bevorzugten Methode zur AWS CLI Eingabe der Anmeldeinformationen werden Sie aufgefordert, die entsprechenden Informationen einzugeben. Standardmäßig werden die Informationen in diesem Profil verwendet, wenn Sie einen AWS CLI Befehl ausführen, der nicht explizit ein zu verwendendes Profil angibt.
Weitere Informationen zu den Dateien `credentials` und `config` finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
------
#### [ 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
```
------
Ausführliche Informationen zu Authentifizierungs- und Anmeldeinformationsmethoden finden Sie unter [Authentifizierungs- und Zugangsdaten für die AWS CLI](cli-chap-authentication.md).
### Manuelles Bearbeiten der Anmeldeinformationen und Konfigurationsdateien
Beim Kopieren und Einfügen von Informationen empfehlen wir, die Datei `config` und `credentials` manuell zu bearbeiten. Je nach der von Ihnen bevorzugten Anmeldeinformationsmethode werden die Dateien auf unterschiedliche Weise eingerichtet.
Die Dateien werden in Ihrem Stammverzeichnis unter dem Ordner `.aws` gespeichert. 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. Weitere Informationen zum Speicherort dieser Einstellungen finden Sie unter [Wo werden Konfigurationseinstellungen gespeichert?](cli-configure-files.md#cli-configure-files-where).
Die folgenden Beispiele zeigen ein `default`-Profil und ein Profil mit dem Namen `user1` und verwenden Beispielwerte. Ersetzen Sie die Beispielwerte durch Ihre eigenen Werte. Weitere Informationen zu den Dateien `credentials` und `config` finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
------
#### [ 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
```
------
Ausführliche Informationen zu Authentifizierungs- und Anmeldeinformationsmethoden finden Sie unter [Authentifizierungs- und Zugangsdaten für die AWS CLI](cli-chap-authentication.md).
## Verwenden vorhandener Konfigurations- und Anmeldeinformationen
Wenn Sie über vorhandene Konfigurations- und Anmeldeinformationen verfügen, können diese für die AWS CLI verwenden.
Um die Dateien `config` und `credentials` zu verwenden, verschieben Sie sie in den Ordner namens `.aws` in Ihrem Hauptverzeichnis. 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 `config` und `credentials` angeben, indem Sie die Umgebungsvariablen `AWS_CONFIG_FILE` und `AWS_SHARED_CREDENTIALS_FILE` auf einen anderen lokalen Pfad setzen. Details dazu finden Sie unter [Konfiguration von Umgebungsvariablen für AWS CLI](cli-configure-envvars.md).
Weitere Informationen zu Konfigurations- und Anmeldeinformationen-Dateien finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).