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.
# Einrichtung der EB-Befehlszeilenschnittstelle (EB CLI) zur Verwaltung von Elastic Beanstalk
Die EB CLI ist eine Befehlszeilenschnittstelle, die interaktive Befehle zum Erstellen, Aktualisieren und Überwachen von Umgebungen bereitstellt AWS Elastic Beanstalk. Das EB CLI Open-Source-Projekt ist auf Github: `[aws/aws-elastic-beanstalk-cli](https://github.com/aws/aws-elastic-beanstalk-cli)`
Nachdem Sie die EB-CLI installiert und ein Projektverzeichnis konfiguriert haben, können Sie Umgebungen mit nur einem Befehl erstellen:
```
$ eb create my-beanstalk-environment
```
Wir empfehlen die Installation mit dem Setup-Skript. Wie das geht, erfahren Sie unter[EB CLI mit Setup-Skript installieren (empfohlen)](#eb-cli3-install).
Das AWS CLI bietet direkten Zugriff auf Elastic APIs Beanstalk auf niedriger Ebene. Es ist zwar leistungsstark, aber auch ausführlich und wird der EB-CLI weniger bevorzugt. Zum Erstellen einer Umgebung mit dem AWS CLI sind beispielsweise die folgenden Befehle erforderlich:
```
$ aws elasticbeanstalk check-dns-availability \
--cname-prefix my-cname
$ aws elasticbeanstalk create-application-version \
--application-name my-application \
--version-label v1 \
--source-bundle S3Bucket=amzn-s3-demo-bucket,S3Key=php-proxy-sample.zip
$ aws elasticbeanstalk create-environment \
--cname-prefix my-cname \
--application-name my-app \
--version-label v1 \
--environment-name my-env \
--solution-stack-name "64bit Amazon Linux 2023 v4.5.0 running Ruby 3.4"
```
## EB CLI mit Setup-Skript installieren (empfohlen)
**Wir empfehlen das Installationsskript**
Wir empfehlen, das Installationsskript zu verwenden, um die EB-CLI und ihre Abhängigkeiten einzurichten und mögliche Konflikte mit anderen Python-Paketen zu vermeiden.
[Voraussetzungen: Git, Python und virtualenv](https://virtualenv.pypa.io/en/latest/installation.html)
**Um das Installationsskript herunterzuladen und zu verwenden**
1. Klonen Sie das Repository
```
git clone https://github.com/aws/aws-elastic-beanstalk-cli-setup.git
```
1. Installieren oder aktualisieren Sie die EB-CLI.
**macOS//Linux** in Bash oder Zsh
```
python ./aws-elastic-beanstalk-cli-setup/scripts/ebcli_installer.py
```
**Windows im PowerShell oder Befehlsfenster**
```
python .\aws-elastic-beanstalk-cli-setup\scripts\ebcli_installer.py
```
1. Überprüfen Sie, ob die EB CLI ordnungsgemäß installiert wurde.
```
$ eb --version
EB CLI 3.21.0 (Python 3.12)
```
Vollständige Installationsanweisungen finden Sie im [https://github.com/aws/aws-elastic-beanstalk-cli-setup](https://github.com/aws/aws-elastic-beanstalk-cli-setup)Repository unter GitHub.
## Manuelle Installation der EB-CLI
Sie können die EB-CLI unter Linux, macOS und Windows mit dem `pip` Paketmanager für Python installieren, der die Installation, Aktualisierung und Entfernung von Python-Paketen und deren Abhängigkeiten ermöglicht.
**Wir empfehlen das Installationsskript**
Wir empfehlen die Verwendung von[Installieren Sie EB CLI](#eb-cli3-install), um die EB-CLI einzurichten und Abhängigkeitskonflikte zu vermeiden.
**Voraussetzung**: Sie müssen eine unterstützte Version von Python installiert haben. Sie können es von der [Python-Download-Seite](https://www.python.org/downloads/) auf der Python-Website herunterladen.
**So installieren Sie die EB-CLI (manuell)**
1. Führen Sie den folgenden Befehl aus.
```
$ pip install awsebcli --upgrade --user
```
Die Option `--upgrade` weist `pip` an, alle bereits installierten Anforderungen zu aktualisieren. Die Option `--user` bewirkt, dass `pip` das Programm in ein Unterverzeichnis Ihres Benutzerverzeichnisses installiert, damit keine vom Betriebssystem verwendeten Bibliotheken geändert werden.
**Beheben von -Problemen**
Falls bei der Installation der EB CLI mit `pip` Probleme auftreten, können Sie die [EB CLI in einer virtuellen Umgebung installieren](#eb-cli3-install-virtualenv), um das Tool und seine Abhängigkeiten zu isolieren, oder eine Python-Version verwenden, die Sie normalerweise nicht nutzen.
1. Fügen Sie den Pfad der ausführbaren Datei zu Ihrer `PATH`-Variable hinzu:
+ Unter Linux und macOS:
**Linux** – `~/.local/bin`
**macOS** – `~/Library/Python/3.12/bin`
So ändern Sie die `PATH`-Variable (Linux, Unix oder macOS):
1. Suchen Sie das Profilskript für die Shell in Ihrem Benutzerordner. Wenn Sie nicht sicher sind, welche Shell Sie haben, führen Sie `echo $SHELL` aus.
```
$ ls -a ~
. .. .bash_logout .bash_profile .bashrc Desktop Documents Downloads
```
+ **Bash** – `.bash_profile`, `.profile` oder `.bash_login`.
+ **Zsh** – `.zshrc`
+ **Tcsh** – `.tcshrc`, `.cshrc` oder `.login`.
1. Fügen Sie dem Profilskript einen Exportbefehl hinzu. Im folgenden Beispiel wird der Pfad, der durch dargestellt wird*LOCAL\$1PATH*, zur aktuellen `PATH` Variablen hinzugefügt.
```
export PATH=LOCAL_PATH:$PATH
```
1. Laden Sie das im ersten Schritt beschriebene Profilskript in die aktuelle Sitzung. Im folgenden Beispiel wird das Profilskript geladen, das durch dargestellt wird*PROFILE\$1SCRIPT*.
```
$ source ~/PROFILE_SCRIPT
```
+ Unter Windows:
**Python 3.12** — `%USERPROFILE%\AppData\Roaming\Python\Python312\Scripts`
**Python frühere Versionen** – `%USERPROFILE%\AppData\Roaming\Python\Scripts`
So ändern Sie Ihre `PATH`-Variable (Windows):
1. Betätigen Sie die Windows-Taste und geben Sie anschließend ei **environment variables**.
1. Wählen Sie **Edit environment variables for your account (Umgebungsvariablen für Ihr Konto bearbeiten)**.
1. Wählen Sie **PATH (PFAD)** und **Edit (Bearbeiten)** aus.
1. Fügen Sie im Feld **Variable value (Variablenwert)** Pfade hinzu, getrennt durch Semikola. Beispiel: `C:\item1\path;C:\item2\path`
1. Klicken Sie zweimal auf **OK**, um die neuen Einstellungen anzuwenden.
1. Schließen Sie alle laufenden Eingabeaufforderungsfenster und öffnen Sie dann erneut ein Eingabeaufforderungsfenster.
1. Überprüfen Sie, ob die EB CLI korrekt installiert wurde, indem Sie **eb --version** ausführen.
```
$ eb --version
EB CLI 3.21.0 (Python 3.12)
```
Durch regelmäßige Aktualisierungen der EB CLI werden Funktionalitäten zur Unterstützung [der neuesten Elastic Beanstalk-Funktionen](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/) hinzugefügt. Führen Sie das Installationsprogramm erneut aus, um auf die neueste Version der EB CLI zu aktualisieren.
```
$ pip install awsebcli --upgrade --user
```
Wenn Sie die EB CLI deinstallieren müssen, verwenden Sie `pip uninstall`.
```
$ pip uninstall awsebcli
```
## Installieren der EB-CLI in einer virtuellen Umgebung
Sie können Versionsanforderungskonflikte mit anderen `pip`-Paketen vermeiden, indem Sie die EB CLI in einer virtuellen Umgebung installieren.
**So installieren Sie die EB CLI in einer virtuellen Umgebung:**
1. Installieren Sie zuerst mit. `virtualenv` `pip`
```
$ pip install --user virtualenv
```
1. Erstellen Sie eine virtuelle Umgebung.
```
$ virtualenv ~/eb-ve
```
Mithilfe der Option `-p` können Sie eine andere als die standardmäßige ausführbare Python-Datei verwenden.
```
$ virtualenv -p /usr/bin/python3.12 ~/eb-ve
```
1. Aktivieren Sie die virtuelle Umgebung.
**Linux, Unix oder macOS**
```
$ source ~/eb-ve/bin/activate
```
**Windows**
```
$ %USERPROFILE%\eb-ve\Scripts\activate
```
1. Installieren Sie die EB CLI.
```
(eb-ve)$ pip install awsebcli --upgrade
```
1. Überprüfen Sie, ob die EB CLI ordnungsgemäß installiert wurde.
```
$ eb --version
EB CLI 3.23.0 (Python 3.12)
```
Sie können den Befehl `deactivate` verwenden, um die virtuelle Umgebung zu beenden. Führen Sie den Aktivierungsbefehl bei jedem Start einer neuen Sitzung erneut aus.
Führen Sie das Installationsprogramm erneut aus, um auf die neueste Version zu aktualisieren.
```
(eb-ve)$ pip install awsebcli --upgrade
```
## Installieren der EB-CLI mit Homebrew
In der Regel ist die neueste EB CLI-Version für `Homebrew` einige Tage nach der Veröffentlichung für `pip` verfügbar.
**Wir empfehlen das Installationsskript**
Wir empfehlen die Verwendung von[Installieren Sie EB CLI](#eb-cli3-install), um die EB-CLI einzurichten und Abhängigkeitskonflikte zu vermeiden.
**So installieren Sie die EB CLI mit `Homebrew`:**
1. Stellen Sie sicher, dass Sie über die neueste Version von `Homebrew` verfügen.
```
$ brew update
```
1. Führen Sie `brew install awsebcli`.
```
$ brew install awsebcli
```
1. Überprüfen Sie, ob die EB CLI ordnungsgemäß installiert wurde.
```
$ eb --version
EB CLI 3.21.0 (Python 3.12)
```
# Konfigurieren der EB CLI
Nach [der Installation der EB-CLI](eb-cli3.md#eb-cli3-install) können Sie Ihr Projektverzeichnis und die EB-CLI konfigurieren, indem Sie Folgendes **eb init** ausführen. Das folgende Beispiel zeigt die Konfigurationsschritte **eb init** bei der ersten Ausführung in einem Projektordner mit dem Namen`eb`.
**So initialisieren Sie ein EB CLI-Projekt**
1. Zunächst werden Sie von der EB CLI aufgefordert, eine Region auszuwählen. Wählen Sie Ihre bevorzugte Region.
```
~/eb $ eb init
Select a default region
1) us-east-1 : US East (N. Virginia)
2) us-west-1 : US West (N. California)
3) us-west-2 : US West (Oregon)
4) eu-west-1 : Europe (Ireland)
5) eu-central-1 : Europe (Frankfurt)
6) ap-south-1 : Asia Pacific (Mumbai)
7) ap-southeast-1 : Asia Pacific (Singapore)
...
(default is 3): 3
```
1. Wenn Sie dazu aufgefordert werden, geben Sie Ihren Zugriffsschlüssel und Ihren geheimen Schlüssel ein, damit die EB CLI Ressourcen für Sie verwalten kann. Zugriffsschlüssel werden in der AWS Identity and Access Management Konsole erstellt. Wenn Sie keine Schlüssel haben, finden Sie weitere Informationen unter [Wie erhalte ich Sicherheitsanmeldeinformationen?](https://docs.aws.amazon.com/general/latest/gr/getting-aws-sec-creds.html) im *Allgemeine Amazon Web Services-Referenz*.
```
You have not yet set up your credentials or your credentials are incorrect.
You must provide your credentials.
(aws-access-id): AKIAJOUAASEXAMPLE
(aws-secret-key): 5ZRIrtTM4ciIAvd4EXAMPLEDtm+PiPSzpoK
```
1. Eine Elastic Beanstalk Beanstalk-Anwendung ist eine Ressource, die eine Reihe von Anwendungsversionen (Quelle), Umgebungen und gespeicherten Konfigurationen enthält, die einer einzelnen Webanwendung zugeordnet sind. Jedes Mal, wenn Sie Ihren Quellcode mit der EB CLI in Elastic Beanstalk bereitstellen, wird eine neue Anwendungsversion erstellt und der Liste hinzugefügt.
```
Select an application to use
1) [ Create new Application ]
(default is 1): 1
```
1. Der Standard-Anwendungsname ist der Name des Ordners, in dem Sie **eb init** ausführen. Geben Sie einen beliebigen Namen ein, der Ihr Projekt beschreibt.
```
Enter Application Name
(default is "eb"): eb
Application eb has been created.
```
1. Wählen Sie eine Plattform, die mit der Sprache oder dem Framework, in der bzw. in dem Ihre Webanwendung entwickelt wurde, übereinstimmt. Wenn Sie noch keine Anwendung entwickelt haben, wählen Sie eine Plattform, die Sie interessiert. Wir zeigen Ihnen in Kürze, wie Sie eine Beispielanwendung starten. Sie können diese Einstellung zu einem späteren Zeitpunkt jederzeit ändern.
```
Select a platform.
1) .NET Core on Linux
2) .NET on Windows Server
3) Docker
4) Go
5) Java
6) Node.js
7) PHP <== select platform by number
8) Packer
9) Python
10) Ruby
11) Tomcat
(make a selection):7
```
1. Wählen Sie einen bestimmten Plattformzweig aus.
```
Select a platform branch.
1) PHP 8.4 running on 64bit Amazon Linux 2023
2) PHP 8.3 running on 64bit Amazon Linux 2023
3) PHP 8.2 running on 64bit Amazon Linux 2023
4) PHP 8.1 running on 64bit Amazon Linux 2023
5) PHP 8.1 running on 64bit Amazon Linux 2
(default is 1):1
```
1. Wählen Sie **Yes (Ja)**, um den Instances in Ihrer Elastic Beanstalk-Umgebung ein SSH-Schlüsselpaar zuzuweisen. Auf diese Weise können Sie eine direkte Verbindung für die Fehlerbehebung herstellen.
```
Do you want to set up SSH for your instances?
(y/n): y
```
1. Wählen Sie ein vorhandenes Schlüsselpaar oder erstellen Sie ein neues. Damit mit **eb init** ein neues Schlüsselpaar erstellt werden kann, müssen Sie **ssh-keygen** auf Ihrem lokalen Computer installiert haben und über die Befehlszeile darauf zugreifen können. Die EB CLI registriert das neue key pair EC2 für Sie bei Amazon und speichert den privaten Schlüssel lokal in einem Ordner mit dem Namen `.ssh` in Ihrem Benutzerverzeichnis.
```
Select a keypair.
1) [ Create new KeyPair ]
(default is 1): 1
```
Ihre EB CLI-Installation ist nun konfiguriert und einsatzbereit.
**Topics**
+ [Ignorieren von Dateien, die .ebignore verwenden](#eb-cli3-ebignore)
+ [Verwenden von benannten Profilen](#eb-cli3-profile)
+ [Bereitstellen eines Artefakts anstelle des Projektordners](#eb-cli3-artifact)
+ [Konfigurationseinstellungen und Vorrang](#eb-cli3-credentials)
+ [Instance-Metadaten](#eb-cli3-metadata)
## Ignorieren von Dateien, die .ebignore verwenden
Sie können die EB CLI anweisen, bestimmte Dateien in Ihrem Projektverzeichnis zu ignorieren, indem Sie dem Verzeichnis die Datei `.ebignore` hinzufügen. Diese Datei funktioniert wie eine `.gitignore`-Datei. Bei der Bereitstellung Ihres Projektverzeichnisses für Elastic Beanstalk und der Erstellung einer neuen Anwendungsversion schließt die EB CLI keine Dateien ein, die als `.ebignore` im von ihr erstellten Quell-Bundle angegeben werden.
Wenn keine `.ebignore` vorhanden ist, jedoch eine `.gitignore`, ignoriert die EB CLI die Dateien, die in `.gitignore` angegeben sind. Wenn `.ebignore` vorhanden ist, liest die EB CLI `.gitignore` nicht.
Wenn `.ebignore` vorhanden ist, verwendet die EB CLI keine git-Befehle zum Erstellen Ihres Quell-Bundles. Das bedeutet, EB-CLI ignoriert die in `.ebignore` angegebenen Dateien und bindet alle anderen Dateien ein. Insbesondere bindet sie nicht festgeschriebene Quelldateien ein.
**Anmerkung**
Unter Windows bewirkt das Hinzufügen von `.ebignore`, dass die EB CLI symbolischen Links folgt und die verknüpfte Datei bei der Erstellung eines Quell-Bundle einschließt. Das Problem ist bekannt und wird in einem der nächsten Updates behoben.
## Verwenden von benannten Profilen
Wenn Sie Ihre Anmeldeinformationen in einer `credentials`- oder `config`-Datei als benanntes Profil speichern, können Sie die [`--profile`](eb3-cmd-options.md)-Option zur expliziten Angabe eines Profils verwenden. Mit dem folgenden Befehl wird beispielsweise eine neue Anwendung mit dem `user2`-Profil erstellt.
```
$ eb init --profile user2
```
Sie können auch das Standard-Profil ändern, indem Sie die `AWS_EB_PROFILE`-Umgebungsvariable festlegen. Wenn diese Variable festgelegt ist, liest die EB CLI Anmeldeinformationen aus dem angegebenen Profil anstatt `default` oder **eb-cli**.
**Linux, macOS oder Unix**
```
$ export AWS_EB_PROFILE=user2
```
**Windows**
```
> set AWS_EB_PROFILE=user2
```
## Bereitstellen eines Artefakts anstelle des Projektordners
Sie können die EB CLI anweisen, eine ZIP- oder WAR-Datei bereitzustellen, die Sie als Teil eines separaten Erstellungsprozess generieren, indem Sie die folgenden Zeilen zu `.elasticbeanstalk/config.yml` in Ihrem Projektordner hinzufügen.
```
deploy:
artifact: path/to/buildartifact.zip
```
Wenn Sie die EB CLI in Ihrem [Git-Repository](eb3-cli-git.md) konfigurieren und das Artifact nicht in Ihrer Quelle bereitstellen, verwenden Sie die `--staged`-Option zur Bereitstellung des neuesten Builds.
```
~/eb$ eb deploy --staged
```
## Konfigurationseinstellungen und Vorrang
Die EB CLI verwendet eine *Anbieterkette*, um an verschiedenen Stellen nach AWS Anmeldeinformationen zu suchen, einschließlich System- oder Benutzerumgebungsvariablen und lokalen AWS Konfigurationsdateien.
Die EB CLI sucht in der folgenden Reihenfolge nach Anmeldeinformationen und Konfigurationseinstellungen:
1. **Befehlszeilenoptionen** – Geben Sie ein benanntes Profil mit `--profile` an, um die Standardeinstellungen zu überschreiben.
1. **Umgebungsvariablen** – `AWS_ACCESS_KEY_ID` und `AWS_SECRET_ACCESS_KEY`.
1. **Die AWS Anmeldeinformationsdatei** — Befindet sich `~/.aws/credentials` auf Linux- und OS X-Systemen oder `C:\Users\USERNAME\.aws\credentials` unter Windows-Systemen. Diese Datei kann zusätzlich zu einem Standardprofil mehrere benannte Profile enthalten.
1. **Die [AWS CLI -Konfigurationsdatei](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-config-files)** – Gespeichert in `~/.aws/config` auf Linux- und OS X-Systemen oder in `C:\Users\USERNAME\.aws\config` auf Windows-Systemen. Diese Datei kann ein Standardprofil, [benannte Profile](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-multiple-profiles) und jeweils AWS CLI spezifische Konfigurationsparameter enthalten.
1. **Bestehende EB CLI-Konfigurationsdatei** – Gespeichert in `~/.elasticbeanstalk/config` auf Linux- und OS X-Systemen oder in `C:\Users\USERNAME\.elasticbeanstalk\config` auf Windows-Systemen.
1. **Anmeldeinformationen für das Instance-Profil** — Diese Anmeldeinformationen können auf EC2 Amazon-Instances mit einer zugewiesenen Instance-Rolle verwendet werden und werden über den EC2 Amazon-Metadatenservice bereitgestellt. Das [Instance-Profil](concepts-roles-instance.md) muss über die Berechtigung zur Nutzung von Elastic Beanstalk verfügen.
Wenn die Datei mit den Anmeldeinformationen ein benanntes Profil mit dem Namen "eb-cli" enthält, zieht die EB CLI dieses Profil dem Standard-Profil vor. Wenn keine Profile gefunden werden oder ein Profil gefunden wird, dieses jedoch nicht über die Berechtigung zur Nutzung von Elastic Beanstalk verfügt, fordert die EB CLI Sie auf, Schlüssel einzugeben.
## Instance-Metadaten
Um die EB-CLI von einer EC2 Amazon-Instance aus zu verwenden, erstellen Sie eine Rolle, die Zugriff auf die benötigten Ressourcen hat, und weisen Sie diese Rolle der Instance zu, wenn sie gestartet wird. Starten Sie die Instance und installieren Sie die EB CLI mit `pip`.
```
~$ sudo pip install awsebcli
```
`pip` ist auf Amazon Linux vorinstalliert.
Die EB CLI liest die Anmeldeinformationen aus den Instance-Metadaten. Weitere Informationen finden Sie im *IAM-Benutzerhandbuch* unter [Gewähren des Zugriffs auf AWS Ressourcen für Anwendungen, die auf EC2 Amazon-Instances ausgeführt](https://docs.aws.amazon.com/IAM/latest/UserGuide/role-usecase-ec2app.html) werden.
# Verwenden der EB CLI mit Git
Die EB-CLI bietet eine Git-Integration, sodass Sie Code-Branches bestimmten Umgebungen in Elastic Beanstalk zuordnen können, um Ihre Deployments zu organisieren.
**So installieren Sie Git und initialisieren Ihr Git-Repository**
1. Laden Sie die neueste Version von Git unter [http://git-scm.com](http://git-scm.com) herunter.
1. Initialisieren Sie Ihr Git-Repository, indem Sie den folgenden Befehl eingeben:
```
~/eb$ git init
```
EB CLI wird nun erkennen, dass Ihre Anwendung mit Git eingerichtet wurde.
1. Wenn Sie **eb init** noch nicht ausgeführt haben, tun Sie dies jetzt:
```
~/eb$ eb init
```
## Zuordnen von Git-Verzweigungen zu Elastic Beanstalk-Umgebungen
Sie können jede Verzweigung Ihres Codes einer anderen Umgebung zuordnen. Wenn Sie eine Verzweigung abschließen, werden Änderungen für die zugeordnete Umgebung bereitgestellt. Sie können beispielsweise Folgendes eingeben, um Ihre Produktionsumgebung Ihrem Mainline-Zweig, und eine separate Entwicklungsumgebung Ihrer Entwicklungsverzweigung zuzuordnen:
```
~/eb$ git checkout mainline
~/eb$ eb use prod
~/eb$ git checkout develop
~/eb$ eb use dev
```
## Bereitstellen von Änderungen
Standardmäßig stellt die EB CLI den neuesten Commit in der aktuellen Verzweigung bereit, wobei die Commit-ID und Nachricht als die Bezeichnung bzw. Beschreibung der Anwendungsversion verwendet wird. Wenn Sie ohne Commit in Ihrer Umgebung bereitstellen möchten, können Sie die `--staged`-Option verwenden, um Änderungen bereitzustellen, die zum Staging-Bereich hinzugefügt wurden.
**So stellen Sie Änderungen ohne Commit bereit**
1. Fügen Sie neue und geänderte Dateien zum Staging-Bereich hinzu:
```
~/eb$ git add .
```
1. Bereitstellen von zwischengespeicherten Änderungen mit **eb deploy**:
```
~/eb$ eb deploy --staged
```
Wenn Sie die EB CLI so konfiguriert haben, dass [ein Artefakt bereitgestellt wird](eb-cli3-configuration.md#eb-cli3-artifact), und Sie das Artefakt nicht in Ihrem git-Repository bereitstellen, verwenden Sie die `--staged`-Option zur Bereitstellung des neuesten Builds.
## Verwenden von Git-Submodulen
Einige Code-Projekte profitieren davon, dass sie Git-Submodul-Repositorys innerhalb des Top-Level-Repository haben. Wenn Sie Ihren Code mithilfe von **eb create** oder **eb deploy** bereitstellen, kann die EB CLI Submodule in die ZIP-Datei der Anwendungsversion einfügen und sie mit den Rest des Codes hochladen.
Sie können die Einbeziehung von Submodulen kontrollieren, indem Sie die Option `include_git_submodules` im Abschnitt `global` der EB CLI-Konfigurationsdatei `.elasticbeanstalk/config.yml` in Ihrem Projektordner verwenden.
Um die Submodule einzubeziehen, legen Sie diese Option auf `true` fest:
```
global:
include_git_submodules: true
```
Wenn die Option `include_git_submodules` fehlt oder auf `false` festgelegt ist, bezieht EB CLI keine Submodule in die hochgeladene ZIP-Datei ein.
Weitere Informationen über Git-Submodule finden Sie unter [Git Tools - Submodules](https://git-scm.com/book/en/v2/Git-Tools-Submodules).
**Standardverhalten**
Wenn Sie **eb init** zum Konfigurieren Ihres Projekts ausführen, fügt die EB CLI die Option `include_git_submodules` hinzu und legt sie auf `true` fest. Auf diese Weise wird sichergestellt, dass alle Submodule, die Sie in Ihrem Projekt haben, in Ihre Bereitstellungen einbezogen werden.
Die EB CLI hat die Einbeziehung von Submodulen nicht immer unterstützt. Um eine versehentliche und unerwünschte Änderung an vorher bereits vorhandenen Projekten zu verhindern, haben wir Submodul-Support hinzugefügt. Die EB CLI bezieht keine Submodule ein, wenn die Option `include_git_submodules` fehlt. Wenn Sie eines dieser vorhandenen Projekte haben und Sie Submodule in Ihren Bereitstellungen einbeziehen möchten, fügen Sie die Option hinzu und legen Sie sie auf `true` fest, wie in diesem Abschnitt erklärt.
**CodeCommit Verhalten**
Die Integration von Elastic Beanstalk mit unterstützt derzeit CodeCommit keine Submodule. Wenn Sie für Ihre Umgebung die Integration mit aktiviert haben CodeCommit, sind Submodule nicht in Ihren Bereitstellungen enthalten.
## Zuweisen von Git-Tags zu Ihrer Anwendungsversion
Sie können ein Git-Tag als Versionsbezeichnung verwenden, um zu identifizieren, welche Anwendungsversion in Ihrer Umgebung ausgeführt wird. Geben Sie zum Beispiel Folgendes ein:
```
~/eb$ git tag -a v1.0 -m "My version 1.0"
```