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.
# Bau und Installation der AWS CLI aus der Quelle
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 AWS CLI installation (Installation)](#source-getting-started-install-verify)
+ [Workflow-Beispiele](#source-getting-started-install-workflows)
+ [Fehlerbehebung AWS CLI Fehler bei der Installation und Deinstallation](#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 [`musl`](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 Maintainern erhalten Kunden aktuellere Versionen der AWS CLI , wenn sie von einem Drittanbieter-Paketmanager wie `brew`, `yum` und `apt` aus installieren.
+ Kunden, die AWS CLI Funktionen patchen, müssen das Programm direkt aus dem AWS CLI 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 ausführen, die MSYS2 aufrufen, müssen Sie Ihr aktuelles Arbeitsverzeichnis sichern:
```
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 unter C:\\Program Files\\ 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 [Fehlerbehebung AWS CLI Fehler bei der Installation und Deinstallation](#source-install-tshoot).
## Schritt 1: Einrichten aller Anforderungen
Um den AWS CLI From-Quellcode zu erstellen, müssen Sie zuvor Folgendes erledigt haben:
**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/awscli- {{versionnumber}} .tar.gz](https://awscli.amazonaws.com/awscli.tar.gz)
[Für Version 2.10.0 lautet der Link beispielsweise wie folgt: .tar.gz https://awscli.amazonaws.com/awscli- {{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 `.zip` Installationspaketdateien 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
akV0ygUJDqP4lQAKCRCmMQrMRnJHXFHjD/9eyZLYcKuQOlLvtqSDtUBiEZf6ZZjM
i3ygYH8rJNtuToUH+HvSpe819urJCquXhDrlK6N+aqW0hCLtNABJG/vsafIgvIYJ
hSGgpgtNnQyMV1jViRWqPjbouw8OkYKBThUfT1i2Y+wn58ifs6ODBCmTexWtXspA
Si+Gt49xDOW0APmbOPnI+a4HJW6tVEo6MWS0WjzpiBayR3d1A4pt4YrPfSdDgpLo
h2SLQqlRqvvVZJaWBjhkErNFpfsBA06sDcPEOb0G8LBUbR4WOcdvhe5LubJbZuxC
AG9kNPCVeQP1ixwjgjXKysaxeQ6rv0VzIQgRp6tLVLWhy6AKDNvLjFSsmXZ1Wl08
Y/RlOHXlzLuQMRE6sR1wOdRxc9TsrNWTGiBK65cvSWOy03JeBkQQ8pesqltiyxI9
U21kkgiXtTSKNGfKK8pO27D81YANhRqPK7iTp6kuFiY2WtOg90KTMNlIT+Ff85Y2
b1rHj6Z0SrCkJujhWk3IBPic/wJgz01LEc/OAdUPlby90RJZcIBhSlWhT7mXnXIO
c0HWlNQrns2s3CTyYwZSiSlYe9ApeLwhjDo8NhbFuCAy61l6O5UsR4AfZxx/rGKv
2wFb1/RN/P4gNe6vmxZAPjR0AQcwD3tc2McimOLr/22kmPz8IH3I0X7WoSFr0Biz
E91G7bb0hOb/cA==
=knv7
-----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: 2027-07-01
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 .sig heruntergeladen haben. https://awscli.amazonaws.com/awscli.tar.gz](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-compliant Shell geliefert wird, müssen Sie zusätzliche Software installieren, um die Version AWS CLI aus dem Quellcode zu installieren. [MSYS2](https://www.msys2.org/) bietet eine Sammlung von Tools und Bibliotheken, die beim Erstellen und Installieren von Windows-Software helfen, insbesondere für die von Autotools verwendete POSIX-based Skripterstellung.
1. Installieren Sie MSYS2. Informationen zur Installation und Verwendung von 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 zum Konfigurieren, Erstellen und Installieren in diesem Handbuch zu Windows verwenden, wird der standardmäßige MSYS2-Installationspfad von `C:\msys64\usr\bin\bash` angenommen. Wenn Sie MSYS2 innerhalb von 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](https://aws.amazon.com/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/) und Tools. Ein Interpreter wird nur bis zu 6 Monate nach dem Datum des Support-Endes unterstützt.
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. Mit diesem Befehl werden die Dateien AWS CLI at `/opt/aws-cli` und die ausführbaren Dateien an ihrem Standardspeicherort installiert. `/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. Mit diesem Befehl werden die Dateien AWS CLI in `$HOME/.local/lib/aws-cli` und die ausführbaren Dateien installiert 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 [`AM_PATH_PYTHON`](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)** Erzeugt eine isolierte virtuelle Python-Umgebung, installiert die AWS CLI in der virtuellen Umgebung und fügt Symlinks zur `aws` und `aws_completer` ausführbaren Datei in der virtuellen Umgebung hinzu. 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 [`venv`](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 [`pip-compile`](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 in der Baumstruktur 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), [--no-cache-dir](https://pip.pypa.io/en/stable/cli/pip_install/#caching) und [`--no-index`](https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-index).
**(Optional)** Wenn das `portable-exe` im `configure`-Befehl auf `--install-type` gesetzt ist, wird eine eigenständige ausführbare Datei mithilfe von [`pyinstaller`](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 [`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 die Datei unter installiert wird `{{/tmp/stage/}}usr/local/lib/aws-cli` und sich ihre ausführbaren Dateien in 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 AWS CLI installation (Installation)
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-Einstellung verwendet werden, siehe [Verwenden von MSYS2 in CI](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` durch den Speicherort 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 des Formulars PowerShell mithilfe AWS CLI von MSYS2 und gibt an, 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` durch den Speicherort Ihres MSYS2-Pfads.
+ `C:path\to\cli\repository\`[mit dem Pfad zu Ihrem AWS CLI geklonten Repository von. *GitHub*](https://github.com/aws/aws-cli) *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 des Formulars PowerShell mithilfe AWS CLI von MSYS2 und gibt an, 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, ersetzen Sie es {{AWSCLI\_VERSION}} 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).
## Fehlerbehebung AWS CLI Fehler bei der Installation und Deinstallation
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)