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.

# CodeDeploy Tutorials
<a name="tutorials"></a>

In diesem Abschnitt finden Sie verschiedene Tutorials, anhand derer Sie den Umgang mit CodeDeploy erlernen können.

Die Verfahren in diesen Tutorials enthalten Vorschläge für den Speicherort von Dateien (z. B. c:\$1temp) und die Namen, die Buckets, Unterordnern oder Dateien zugewiesen werden sollen (z. B. amzn-s3-demo-bucket HelloWorldApp, bzw. CodeDeployDemo - EC2 -trust.json). Sie müssen sie jedoch nicht verwenden. Sie können stattdessen an den entsprechenden Stellen eigene Dateispeicherorte und Namen angeben.

**Topics**
+ [Tutorial: Bereitstellung WordPress auf einer Amazon EC2 EC2-Instance (Amazon Linux oder Red Hat Enterprise Linux und Linux, macOS oder Unix)](tutorials-wordpress.md)
+ [Tutorial: Bereite ein „Hallo, Welt\$1“ vor Anwendung mit CodeDeploy (Windows Server)](tutorials-windows.md)
+ [Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)](tutorials-on-premises-instance.md)
+ [Tutorial: Wird verwendet CodeDeploy , um eine Anwendung für eine Auto Scaling Scaling-Gruppe bereitzustellen](tutorials-auto-scaling-group.md)
+ [Tutorial: Verwenden Sie CodeDeploy zum Bereitstellen einer Anwendung von GitHub](tutorials-github.md)
+ [Tutorial: Bereitstellen einer Anwendung in Amazon ECS](tutorial-ecs-deployment.md)
+ [Tutorial: Bereitstellen eines Amazon ECS-Service mit einem Validierungstest](tutorial-ecs-deployment-with-hooks.md)
+ [Tutorial: Bereitstellen einer aktualisierten Lambda-Funktion mit CodeDeploy und dem AWS Serverless Application Model](tutorial-lambda-sam.md)

# Tutorial: Bereitstellung WordPress auf einer Amazon EC2 EC2-Instance (Amazon Linux oder Red Hat Enterprise Linux und Linux, macOS oder Unix)
<a name="tutorials-wordpress"></a>

In diesem Tutorial stellen WordPress Sie ein Open-Source-Blogging-Tool und ein Content-Management-System auf der Basis von PHP und MySQL auf einer einzelnen Amazon EC2 EC2-Instance bereit, auf der Amazon Linux oder Red Hat Enterprise Linux (RHEL) ausgeführt wird.

Nicht das, wonach Sie gesucht haben?
+ Informationen zum Bereitstellen auf einer Amazon EC2 EC2-Instance, auf der stattdessen Windows Server ausgeführt wird, finden Sie unter[Tutorial: Bereite ein „Hallo, Welt\$1“ vor Anwendung mit CodeDeploy (Windows Server)](tutorials-windows.md).
+ Informationen zur Bereitstellung auf einer lokalen Instance statt auf einer Amazon EC2 EC2-Instance finden Sie unter. [Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)](tutorials-on-premises-instance.md)

Die Schritte dieses Tutorials werden aus der Perspektive einer lokalen Entwicklungsmaschine vorgestellt, auf der Linux, macOS oder Unix ausgeführt wird. Sie können die meisten der Schritte auch auf einem lokalen Computer mit Windows durchführen, müssen dann jedoch alle Schritte anpassen, die Befehle wie **chmod** und **wget**, Anwendungen wie sed und Verzeichnispfade wie `/tmp` verwenden.

Bevor Sie mit diesem Tutorial beginnen, müssen Sie sicherstellen, dass die unter [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md) beschriebenen Voraussetzungen erfüllt sind. Dazu gehören die Konfiguration eines Benutzers, die Installation oder Aktualisierung von und die AWS CLI Erstellung eines IAM-Instanzprofils und einer Servicerolle.

**Topics**
+ [Schritt 1: Starten und konfigurieren Sie eine Amazon Linux- oder Red Hat Enterprise Linux Amazon EC2 EC2-Instance](tutorials-wordpress-launch-instance.md)
+ [Schritt 2: Konfigurieren Sie Ihren Quellinhalt für die Bereitstellung auf der Amazon Linux- oder Red Hat Enterprise Linux Amazon EC2 EC2-Instance](tutorials-wordpress-configure-content.md)
+ [Schritt 3: Laden Sie Ihre WordPress Bewerbung auf Amazon S3 hoch](tutorials-wordpress-upload-application.md)
+ [Schritt 4: Stellen Sie Ihre WordPress Anwendung bereit](tutorials-wordpress-deploy-application.md)
+ [Schritt 5: Aktualisieren Sie Ihre WordPress Anwendung und stellen Sie sie erneut bereit](tutorials-wordpress-update-and-redeploy-application.md)
+ [Schritt 6: Bereinigen Sie Ihre WordPress Anwendung und die zugehörigen Ressourcen](tutorials-wordpress-clean-up.md)

# Schritt 1: Starten und konfigurieren Sie eine Amazon Linux- oder Red Hat Enterprise Linux Amazon EC2 EC2-Instance
<a name="tutorials-wordpress-launch-instance"></a>

Um die WordPress Anwendung bereitzustellen CodeDeploy, benötigen Sie eine Amazon EC2 EC2-Instance, auf der Amazon Linux oder Red Hat Enterprise Linux (RHEL) ausgeführt wird. Die Amazon EC2 EC2-Instance erfordert eine neue Sicherheitsregel für eingehenden Datenverkehr, die HTTP-Verbindungen zulässt. Diese Regel ist erforderlich, um die WordPress Seite nach erfolgreicher Bereitstellung in einem Browser anzuzeigen.

Folgen Sie den Anweisungen in [Erstellen Sie eine Amazon EC2 EC2-Instance für CodeDeploy](instances-ec2-create.md). Wenn Sie zu dem Teil in diesen Anweisungen gelangen, in dem es darum geht, der Instance ein Amazon EC2 EC2-Instance-Tag zuzuweisen, geben Sie unbedingt den Tag-Schlüssel von **Name** und den Tag-Wert von an. **CodeDeployDemo** (Wenn Sie einen anderen Tag-Schlüssel oder Tag-Wert angeben, dann können die Anweisungen in [Schritt 4: Stellen Sie Ihre WordPress Anwendung bereit](tutorials-wordpress-deploy-application.md) zu unerwarteten Ergebnissen führen.)

Nachdem Sie die Anweisungen zum Starten der Amazon EC2 EC2-Instance befolgt haben, kehren Sie zu dieser Seite zurück und fahren Sie mit dem nächsten Abschnitt fort. Fahren Sie nicht mit [Erstellen Sie eine Anwendung mit CodeDeploy](applications-create.md) dem nächsten Schritt fort.

## Connect zu Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance her
<a name="tutorials-wordpress-launch-instance-connect"></a>

Nachdem Ihre neue Amazon EC2 EC2-Instance gestartet wurde, folgen Sie diesen Anweisungen, um zu üben, wie Sie sich mit ihr verbinden.

1. Verwenden Sie den **ssh** Befehl (oder einen SSH-fähigen Terminalemulator wie [PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html)), um eine Verbindung zu Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance herzustellen. Sie benötigen die öffentliche DNS-Adresse der Instance und den privaten Schlüssel für das key pair, das Sie beim Starten der Amazon EC2 EC2-Instance verwendet haben. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html) (Verbindung mit der Instance herstellen).

   Wenn die öffentliche DNS-Adresse beispielsweise lautet **ec2-01-234-567-890.compute-1.amazonaws.com** und Ihr Amazon EC2 EC2-Instance-Schlüsselpaar für den SSH-Zugriff benannt ist**codedeploydemo.pem**, würden Sie Folgendes eingeben:

   ```
   ssh -i /path/to/codedeploydemo.pem ec2-user@ec2-01-234-567-890.compute-1.amazonaws.com
   ```

   `/path/to/codedeploydemo.pem`Ersetzen Sie durch den Pfad zu Ihrer `.pem` Datei und die Beispiel-DNS-Adresse durch die Adresse Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance.
**Anmerkung**  
Wenn ein Fehler angezeigt wird, der besagt, dass die Berechtigungen der Schlüsseldatei nicht restriktiv genug sind, müssen Sie diese Berechtigungen einschränken, sodass nur der aktuelle Benutzer (Sie) Zugriff hat. Geben Sie beispielsweise mit dem **chmod** Befehl unter Linux, macOS oder Unix Folgendes ein:

   ```
   chmod 400 /path/to/codedeploydemo.pem
   ```

1. Nachdem Sie sich angemeldet haben, sehen Sie das AMI-Banner für die Amazon EC2 EC2-Instance. Für Amazon Linux sollte es so aussehen:

   ```
          __|  __|_  )
          _|  (     /   Amazon Linux AMI
         ___|\___|___|
   ```

1. Sie können sich jetzt von der laufenden Amazon EC2 EC2-Instance abmelden.
**Warnung**  
Beenden oder beenden Sie die Amazon EC2 EC2-Instance nicht. Andernfalls kann sie CodeDeploy nicht bereitgestellt werden.

## Fügen Sie eine Regel für eingehenden Datenverkehr hinzu, die HTTP-Verkehr zu Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance zulässt
<a name="tutorials-wordpress-launch-instance-add-inbound-rule"></a>

Im nächsten Schritt wird bestätigt, dass Ihre Amazon EC2 EC2-Instance über einen offenen HTTP-Port verfügt, sodass Sie die Startseite der bereitgestellten WordPress Anwendung in einem Browser sehen können. 

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie **Instances** und dann Ihre Instance aus. 

1. Wählen Sie auf der Registerkarte **Beschreibung** unter **Sicherheitsgruppen** die Option **Regeln für eingehenden Datenverkehr anzeigen** aus. 

   In Ihrer Sicherheitsgruppe sollte eine Liste mit Regeln wie die folgende angezeigt werden:

   ```
   Security Groups associated with i-1234567890abcdef0
    Ports     Protocol     Source     launch-wizard-N
    22        tcp          0.0.0.0/0          ✔
   ```

1.  Wählen Sie unter **Sicherheitsgruppen** die Sicherheitsgruppe für Ihre Amazon EC2 EC2-Instance aus. Ein möglicher Name ist **launch-wizard-*N***. Beim ***N*** im Namen handelt es sich um eine Nummer, die Ihrer Sicherheitsgruppe beim Erstellen Ihrer Instance zugewiesen wurde. 

    Wählen Sie die Registerkarte **Inbound (Eingehend)**. Wenn die Sicherheitsgruppe für Ihre Instance korrekt konfiguriert ist, sollte Ihnen eine Regel mit den folgenden Werten angezeigt werden: 
   + **Typ**: HTTP
   + **Protocol (Protokoll)**: TCP
   + **Portbereich**: 80
   + **Quelle**: 0.0.0.0/0

1.  Wenn Sie keine Regel mit diesen Werten sehen, gehen Sie wie unter [Regeln zu einer Sicherheitsgruppe hinzufügen beschrieben vor, um sie einer neuen Sicherheitsregel](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) hinzuzufügen. 

# Schritt 2: Konfigurieren Sie Ihren Quellinhalt für die Bereitstellung auf der Amazon Linux- oder Red Hat Enterprise Linux Amazon EC2 EC2-Instance
<a name="tutorials-wordpress-configure-content"></a>

Jetzt ist es an der Zeit, die Quellinhalte Ihrer Anwendung zu konfigurieren, damit Sie Inhalte haben, die Sie auf der Instance bereitstellen können.

**Topics**
+ [Holen Sie sich den Quellcode](#tutorials-wordpress-configure-content-download-code)
+ [Erstellen Sie Skripts, um Ihre Anwendung auszuführen](#tutorials-wordpress-configure-content-create-scripts)
+ [Fügen Sie eine Anwendungsspezifikationsdatei hinzu](#tutorials-wordpress-configure-content-add-appspec-file)

## Holen Sie sich den Quellcode
<a name="tutorials-wordpress-configure-content-download-code"></a>

In diesem Tutorial stellen Sie die Plattform zur Veröffentlichung von WordPress Inhalten von Ihrem Entwicklungscomputer auf der Amazon EC2 EC2-Zielinstanz bereit. Um den WordPress Quellcode abzurufen, können Sie integrierte Befehlszeilenaufrufe verwenden. Wenn Sie auf Ihrem Entwicklungscomputer Git installiert haben, können Sie stattdessen auch Git verwenden.

Für diese Schritte gehen wir davon aus, dass Sie eine Kopie des WordPress Quellcodes in das `/tmp` Verzeichnis auf Ihrem Entwicklungscomputer heruntergeladen haben. (Sie können jedes beliebige Verzeichnis wählen. Denken Sie aber daran, den Speicherort für `/tmp` zu ersetzen, wenn dies in den folgenden Schritten angegeben ist.)

Wählen Sie eine der folgenden beiden Optionen, um die WordPress Quelldateien auf Ihren Entwicklungscomputer zu kopieren. Bei der ersten Option werden integrierte Befehlszeilenaufrufe genutzt. Bei der zweiten Option wird Git verwendet.

**Topics**
+ [Um eine Kopie des WordPress Quellcodes zu erhalten (integrierte Befehlszeilenaufrufe)](#tutorials-wordpress-configure-content-download-code-command-line)
+ [Um eine Kopie des WordPress Quellcodes zu erhalten (Git)](#tutorials-wordpress-configure-content-download-code-git)

### Um eine Kopie des WordPress Quellcodes zu erhalten (integrierte Befehlszeilenaufrufe)
<a name="tutorials-wordpress-configure-content-download-code-command-line"></a>

1. Rufen Sie den **wget** Befehl auf, um eine Kopie des WordPress Quellcodes als ZIP-Datei in das aktuelle Verzeichnis herunterzuladen:

   ```
   wget https://github.com/WordPress/WordPress/archive/master.zip
   ```

1. Rufen Sie die Befehle **unzip**, **mkdir**, **cp** und **rm** auf, um:
   + die `master` .zip-Datei im `/tmp/WordPress_Temp`-Verzeichnis (Ordner) zu entpacken.
   + den entpackten Inhalt in den `/tmp/WordPress`-Zielordner zu kopieren.
   + den temporären `/tmp/WordPress_Temp`-Ordner und die `master`-Datei zu löschen.

   Führen Sie die Befehle einzeln aus:

   ```
   unzip master -d /tmp/WordPress_Temp
   ```

   ```
   mkdir -p /tmp/WordPress
   ```

   ```
   cp -paf /tmp/WordPress_Temp/WordPress-master/* /tmp/WordPress
   ```

   ```
   rm -rf /tmp/WordPress_Temp
   ```

   ```
   rm -f master
   ```

   Dadurch erhalten Sie einen sauberen Satz von WordPress Quellcodedateien im `/tmp/WordPress` Ordner.

### Um eine Kopie des WordPress Quellcodes zu erhalten (Git)
<a name="tutorials-wordpress-configure-content-download-code-git"></a>

1. Laden Sie [Git](http://git-scm.com) auf Ihren Entwicklungscomputer herunter und installieren Sie das Programm.

1. Rufen Sie im Ordner `/tmp/WordPress` den Befehl **git init** auf. 

1. Rufen Sie den **git clone** Befehl zum Klonen des öffentlichen WordPress Repositorys auf und erstellen Sie Ihre eigene Kopie davon im `/tmp/WordPress` Zielordner:

   ```
   git clone https://github.com/WordPress/WordPress.git /tmp/WordPress
   ```

   Dadurch erhalten Sie einen sauberen Satz von WordPress Quellcodedateien im `/tmp/WordPress` Ordner.

## Erstellen Sie Skripts, um Ihre Anwendung auszuführen
<a name="tutorials-wordpress-configure-content-create-scripts"></a>

Erstellen Sie als Nächstes einen Ordner und Skripts im Verzeichnis. CodeDeploy verwendet diese Skripts, um Ihre Anwendungsrevision auf der Amazon EC2 EC2-Zielinstanz einzurichten und bereitzustellen. Sie können zum Erstellen der Skripts jeden beliebigen Texteditor verwenden.

1. Erstellen Sie ein Skriptverzeichnis in Ihrer Kopie des WordPress Quellcodes:

   ```
   mkdir -p /tmp/WordPress/scripts
   ```

1. Erstellen Sie eine `install_dependencies.sh`-Datei in `/tmp/WordPress/scripts`. Fügen Sie der Datei die folgenden Zeilen hinzu. Dieses `install_dependencies.sh`-Skript installiert Apache, MySQL und PHP. Außerdem wird MySQL-Support für PHP hinzugefügt.

   ```
   #!/bin/bash
   sudo amazon-linux-extras install php7.4
   sudo yum install -y httpd mariadb-server php
   ```

1. Erstellen Sie eine `start_server.sh`-Datei in `/tmp/WordPress/scripts`. Fügen Sie der Datei die folgenden Zeilen hinzu. Dieses `start_server.sh`-Skript startet Apache und MySQL.

   ```
   #!/bin/bash
   systemctl start mariadb.service
   systemctl start httpd.service
   systemctl start php-fpm.service
   ```

1. Erstellen Sie eine `stop_server.sh`-Datei in `/tmp/WordPress/scripts`. Fügen Sie der Datei die folgenden Zeilen hinzu. Dieses `stop_server.sh`-Skript stoppt Apache und MySQL.

   ```
   #!/bin/bash
   isExistApp="pgrep httpd"
   if [[ -n $isExistApp ]]; then
   systemctl stop httpd.service
   fi
   isExistApp=pgrep mysqld
   if [[ -n $isExistApp ]]; then
   systemctl stop mariadb.service
   fi
   isExistApp=pgrep php-fpm
   if [[ -n $isExistApp ]]; then
   systemctl stop php-fpm.service
   
   fi
   ```

1. Erstellen Sie eine `create_test_db.sh`-Datei in `/tmp/WordPress/scripts`. Fügen Sie der Datei die folgenden Zeilen hinzu. Dieses `create_test_db.sh` Skript verwendet MySQL, um eine **test** Datenbank zur Verwendung WordPress zu erstellen.

   ```
   #!/bin/bash
   mysql -uroot <<CREATE_TEST_DB
   CREATE DATABASE IF NOT EXISTS test;
   CREATE_TEST_DB
   ```

1. Erstellen Sie schließlich ein `change_permissions.sh`-Skript in `/tmp/WordPress/scripts`. Damit werden die Ordnerberechtigungen in Apache geändert.
**Wichtig**  
 In diesem Skript wurden die Berechtigungen für den `/tmp/WordPress`-Ordner aktualisiert, damit alle Benutzer darin schreiben können. Dies ist erforderlich, damit WordPress währenddessen in die Datenbank geschrieben werden kann[Schritt 5: Aktualisieren Sie Ihre WordPress Anwendung und stellen Sie sie erneut bereit](tutorials-wordpress-update-and-redeploy-application.md). Führen Sie nach der Einrichtung der WordPress Anwendung den folgenden Befehl aus, um die Berechtigungen auf eine sicherere Einstellung zu aktualisieren:  

   ```
   chmod -R 755 /var/www/html/WordPress
   ```

   ```
   #!/bin/bash
   chmod -R 777 /var/www/html/WordPress
   ```

1. Geben Sie allen Skripts ausführbare Berechtigungen. Geben Sie an der Befehlszeile Folgendes ein:

   ```
   chmod +x /tmp/WordPress/scripts/*
   ```

## Fügen Sie eine Anwendungsspezifikationsdatei hinzu
<a name="tutorials-wordpress-configure-content-add-appspec-file"></a>

Fügen Sie als Nächstes eine Anwendungsspezifikationsdatei (Datei) hinzu, eine AppSpec Datei im [YAML-Format](http://www.yaml.org), die von verwendet wird, um: CodeDeploy 
+ Ordnen Sie die Quelldateien in Ihrer Anwendungsrevision ihren Zielen auf der Amazon EC2 EC2-Zielinstanz zu.
+ Geben Sie benutzerdefinierte Berechtigungen für bereitgestellte Dateien an.
+ Geben Sie die Skripts an, die während der Bereitstellung auf der Amazon EC2 EC2-Zielinstanz ausgeführt werden sollen.

Die AppSpec Datei muss benannt `appspec.yml` werden. Sie muss sich im Stammverzeichnis des Anwendungsquellcodes befinden. Das Stammverzeichnis dieses Tutorials ist `/tmp/WordPress`.

Erstellen Sie mit Ihrem Texteditor eine Datei mit dem Namen `appspec.yml`. Fügen Sie der Datei die folgenden Zeilen hinzu:

```
version: 0.0
os: linux
files:
  - source: /
    destination: /var/www/html/WordPress
hooks:
  BeforeInstall:
    - location: scripts/install_dependencies.sh
      timeout: 300
      runas: root
  AfterInstall:
    - location: scripts/change_permissions.sh
      timeout: 300
      runas: root
  ApplicationStart:
    - location: scripts/start_server.sh
    - location: scripts/create_test_db.sh
      timeout: 300
      runas: root
  ApplicationStop:
    - location: scripts/stop_server.sh
      timeout: 300
      runas: root
```

CodeDeploy verwendet diese AppSpec Datei, um alle Dateien im Ordner auf dem Entwicklungscomputer in den `/tmp/WordPress` Ordner auf der `/var/www/html/WordPress` Amazon EC2 EC2-Zielinstanz zu kopieren. CodeDeploy Führt während der Bereitstellung die angegebenen Skripts wie `root` im `/var/www/html/WordPress/scripts` Ordner auf der Amazon EC2 EC2-Zielinstanz zu bestimmten Ereignissen während des Bereitstellungszyklus aus, z. B. **BeforeInstall** und**AfterInstall**. Wenn die Ausführung eines dieser Skripts länger als 300 Sekunden (5 Minuten) dauert, wird die Bereitstellung CodeDeploy gestoppt und die Bereitstellung als fehlgeschlagen markiert.

Weitere Informationen zu diesen Einstellungen finden Sie in der [CodeDeploy AppSpec Dateiverweis](reference-appspec-file.md).

**Wichtig**  
Die Platzierung und Anzahl von Leerzeichen zwischen den einzelnen Elementen in dieser Datei ist wichtig. Wenn der Abstand falsch ist, wird CodeDeploy ein Fehler ausgelöst, der möglicherweise schwer zu debuggen ist. Weitere Informationen finden Sie unter [AppSpec Abstand zwischen den Dateien](reference-appspec-file.md#reference-appspec-file-spacing).

# Schritt 3: Laden Sie Ihre WordPress Bewerbung auf Amazon S3 hoch
<a name="tutorials-wordpress-upload-application"></a>

Jetzt bereiten Sie Ihre Quellinhalte vor und laden sie an einen Ort hoch, von dem aus Sie sie bereitstellen CodeDeploy können. Die folgenden Anweisungen zeigen Ihnen, wie Sie einen Amazon S3 S3-Bucket bereitstellen, die Dateien der Anwendungsrevision für den Bucket vorbereiten, die Dateien der Revision bündeln und dann die Revision in den Bucket übertragen.

**Anmerkung**  
Obwohl dies in diesem Tutorial nicht behandelt wird, können Sie es verwenden, CodeDeploy um Anwendungen von GitHub Repositorys auf Instances bereitzustellen. Weitere Informationen finden Sie unter [Integrieren CodeDeploy mit GitHub](integrations-partners-github.md).

**Topics**
+ [Bereitstellen eines Amazon S3 S3-Buckets](#tutorials-wordpress-upload-application-create-s3-bucket)
+ [Bereiten Sie die Dateien der Anwendung für den Bucket vor](#tutorials-wordpress-upload-application-prepare-application-files)
+ [Bündeln Sie die Dateien der Anwendung in einer einzigen Archivdatei und übertragen Sie die Archivdatei per Push](#tutorials-wordpress-upload-application-bundle-and-push-archive)

## Bereitstellen eines Amazon S3 S3-Buckets
<a name="tutorials-wordpress-upload-application-create-s3-bucket"></a>

Erstellen Sie einen Speichercontainer oder *Bucket* in Amazon S3 — oder verwenden Sie einen vorhandenen Bucket. Stellen Sie sicher, dass Sie die Revision in den Bucket hochladen können und dass Amazon EC2 EC2-Instances, die in Bereitstellungen verwendet werden, die Revision aus dem Bucket herunterladen können.

Sie können die AWS CLI, die Amazon S3-Konsole oder Amazon S3 verwenden, APIs um einen Amazon S3 S3-Bucket zu erstellen. Nachdem Sie den Bucket erstellt haben, stellen Sie sicher, dass Sie Zugriffsberechtigungen für den Bucket und Ihr AWS Konto erteilen.

**Anmerkung**  
Bucket-Namen müssen in Amazon S3 für alle AWS Konten eindeutig sein. Falls Sie **amzn-s3-demo-bucket** nicht verwenden können: Versuchen Sie es mit einem anderen Bucket-Namen wie **amzn-s3-demo-bucket**, gefolgt von einem Bindestrich und Ihren Initialen oder einem anderen eindeutigen Bezeichner. Anschließend müssen Sie überall im Tutorial **amzn-s3-demo-bucket** durch Ihren Bucket-Namen ersetzen.  
Der Amazon S3 S3-Bucket muss in derselben AWS Region erstellt werden, in der Ihre Amazon EC2 EC2-Ziel-Instances gestartet werden. Wenn Sie den Bucket beispielsweise in der Region USA Ost (Nord-Virginia) erstellen, müssen Ihre Amazon EC2 EC2-Ziel-Instances in der Region USA Ost (Nord-Virginia) gestartet werden.

**Topics**
+ [So erstellen Sie einen Amazon S3 S3-Bucket (CLI)](#tutorials-wordpress-upload-application-create-s3-bucket-cli)
+ [So erstellen Sie einen Amazon S3 S3-Bucket (Konsole)](#tutorials-wordpress-upload-application-create-s3-bucket-console)
+ [Erteilen Sie Berechtigungen für den Amazon S3 S3-Bucket und das Amazon AWS S3-Konto](#tutorials-wordpress-upload-application-create-s3-bucket-grant-permissions)

### So erstellen Sie einen Amazon S3 S3-Bucket (CLI)
<a name="tutorials-wordpress-upload-application-create-s3-bucket-cli"></a>

Rufen Sie den **mb** Befehl auf, um einen Amazon S3 S3-Bucket mit dem Namen zu erstellen**amzn-s3-demo-bucket**:

```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```

### So erstellen Sie einen Amazon S3 S3-Bucket (Konsole)
<a name="tutorials-wordpress-upload-application-create-s3-bucket-console"></a>

1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie in der Amazon S3 S3-Konsole **Create Bucket** aus.

1. Geben Sie im Feld **Bucket name (Bucket-Name)** einen Namen für den Bucket ein.

1. Wählen Sie aus der Liste **Region** die Zielregion aus, und klicken Sie auf **Create (Erstellen)**.

### Erteilen Sie Berechtigungen für den Amazon S3 S3-Bucket und das Amazon AWS S3-Konto
<a name="tutorials-wordpress-upload-application-create-s3-bucket-grant-permissions"></a>

Sie müssen über Berechtigungen zum Hochladen in den Amazon S3 S3-Bucket verfügen. Sie können diese Berechtigungen über eine Amazon S3 S3-Bucket-Richtlinie angeben. In der folgenden Amazon S3 S3-Bucket-Richtlinie ermöglicht die Verwendung des Platzhalterzeichens (\$1) dem AWS Konto `111122223333` beispielsweise das Hochladen von Dateien in ein beliebiges Verzeichnis im Amazon S3 S3-Bucket mit dem Namen`amzn-s3-demo-bucket`:

```
{
    "Statement": [
        {
            "Action": [
                "s3:PutObject"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "111122223333"
                ]
            }
        }
    ]
}
```

Informationen zur Anzeige Ihrer AWS Konto-ID [finden Sie unter Ihre AWS Konto-ID finden](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId).

Jetzt ist ein guter Zeitpunkt, um zu überprüfen, ob der Amazon S3 S3-Bucket Download-Anfragen von jeder teilnehmenden Amazon EC2 EC2-Instance zulässt. Sie können dies über eine Amazon S3 S3-Bucket-Richtlinie angeben. In der folgenden Amazon S3 S3-Bucket-Richtlinie ermöglicht die Verwendung des Platzhalterzeichens (\$1) beispielsweise jeder Amazon EC2 EC2-Instance mit einem angehängten IAM-Instance-Profil, das den ARN `arn:aws:iam::444455556666:role/CodeDeployDemo` enthält, Dateien aus einem beliebigen Verzeichnis im Amazon S3 S3-Bucket mit dem Namen herunterzuladen: `amzn-s3-demo-bucket`

```
{
    "Statement": [
        {
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "arn:aws:iam::444455556666:role/CodeDeployDemo"
                ]
            }
        }
    ]
}
```

 Informationen zum Generieren und Anhängen einer Amazon S3 S3-Bucket-Richtlinie finden Sie unter [Beispiele für Bucket-Richtlinien](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).

Informationen zum Erstellen und Anhängen einer IAM-Richtlinie finden Sie unter [Arbeiten mit Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html#AddingPermissions_Console).

## Bereiten Sie die Dateien der Anwendung für den Bucket vor
<a name="tutorials-wordpress-upload-application-prepare-application-files"></a>

Stellen Sie sicher, dass die WordPress Anwendungsdateien, die AppSpec Datei und die Skripts auf Ihrem Entwicklungscomputer ähnlich wie folgt organisiert sind:

```
/tmp/
  |--WordPress/
      |-- appspec.yml  
      |-- scripts/
      |    |-- change_permissions.sh
      |    |-- create_test_db.sh
      |    |-- install_dependencies.sh
      |    |-- start_server.sh
      |    |-- stop_server.sh
      |-- wp-admin/
      |    |-- (various files...)
      |-- wp-content/
      |    |-- (various files...)
      |-- wp-includes/
      |    |-- (various files...)
      |-- index.php
      |-- license.txt
      |-- readme.html
      |-- (various files ending with .php...)
```

## Bündeln Sie die Dateien der Anwendung in einer einzigen Archivdatei und übertragen Sie die Archivdatei per Push
<a name="tutorials-wordpress-upload-application-bundle-and-push-archive"></a>

Bündeln Sie die WordPress Anwendungsdateien und die AppSpec Datei in einer Archivdatei (bekannt als *Anwendungsrevision*).

**Anmerkung**  
Möglicherweise werden Ihnen für die Speicherung von Objekten in einem Bucket und die Übertragung von Anwendungsrevisionen in einen oder aus einem Bucket Gebühren berechnet. Weitere Informationen finden Sie unter [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/). 

1. Wechseln Sie auf dem Entwicklungscomputer in den Ordner, in dem die Dateien abgelegt sind: 

   ```
   cd /tmp/WordPress
   ```
**Anmerkung**  
Wenn Sie nicht in diesen Ordner wechseln, startet die Dateibündelung im jeweils aktuellen Ordner. Beispiel: Wenn der aktuelle Ordner `/tmp` statt `/tmp/WordPress` ist, beginnt der Bündelvorgang mit den Dateien und Unterordnern im Ordner `tmp`, in dem u. U. mehr enthalten ist als bloß die `WordPress`-Unterordner.

1. Rufen Sie den Befehl **create-application** auf, um eine neue Anwendung namens **WordPress\$1App** zu registrieren:

   ```
   aws deploy create-application --application-name WordPress_App
   ```

1. Rufen Sie den CodeDeploy [Push-Befehl](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) auf, um die Dateien zu bündeln, die Revisionen auf Amazon S3 hochzuladen und Informationen CodeDeploy über die hochgeladene Version zu registrieren — alles in einer Aktion. 

   ```
   aws deploy push \
     --application-name WordPress_App \
     --s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip \
     --ignore-hidden-files
   ```

   Dieser Befehl bündelt die Dateien aus dem aktuellen Verzeichnis (mit Ausnahme aller versteckten Dateien) in einer einzigen Archivdatei mit dem Namen**WordPressApp.zip**, lädt die Revision in den **amzn-s3-demo-bucket** Bucket hoch und registriert Informationen CodeDeploy über die hochgeladene Revision.

# Schritt 4: Stellen Sie Ihre WordPress Anwendung bereit
<a name="tutorials-wordpress-deploy-application"></a>

Jetzt stellen Sie die Version der WordPress Beispielanwendung bereit, die Sie auf Amazon S3 hochgeladen haben. Sie können die AWS CLI oder die CodeDeploy Konsole verwenden, um die Version bereitzustellen und den Fortschritt der Bereitstellung zu überwachen. Im Anschluss an die Bereitstellung der Anwendungsrevision überprüfen Sie die Ergebnisse.

**Topics**
+ [Stellen Sie die Revision Ihrer Anwendung bereit mit CodeDeploy](#tutorials-wordpress-deploy-application-create-deployment)
+ [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](#tutorials-wordpress-deploy-application-monitor)
+ [Überprüfen Sie Ihre Bereitstellung](#tutorials-wordpress-deploy-application-verify-deployment)

## Stellen Sie die Revision Ihrer Anwendung bereit mit CodeDeploy
<a name="tutorials-wordpress-deploy-application-create-deployment"></a>

Verwenden Sie die Konsole AWS CLI oder die Konsole, um Ihre Anwendungsrevision bereitzustellen.

**Topics**
+ [Mit der CLI stellen Sie die Anwendungsrevision wie folgt bereit:](#tutorials-wordpress-deploy-application-create-deployment-cli)
+ [Mit der Konsole stellen Sie die Anwendungsrevision wie folgt bereit:](#tutorials-wordpress-deploy-application-create-deployment-console)

### Mit der CLI stellen Sie die Anwendungsrevision wie folgt bereit:
<a name="tutorials-wordpress-deploy-application-create-deployment-cli"></a>

1. Für die Bereitstellung ist eine Bereitstellungsgruppe erforderlich. Bevor Sie die Bereitstellungsgruppe erstellen können, benötigen Sie allerdings den ARN einer Service-Rolle. Eine Servicerolle ist eine IAM-Rolle, die einem Dienst die Erlaubnis erteilt, in Ihrem Namen zu handeln. In diesem Fall erteilt die Service-Rolle die CodeDeploy Erlaubnis, auf Ihre Amazon EC2 EC2-Instances zuzugreifen, um deren Amazon EC2 EC2-Instance-Tags zu erweitern (zu lesen).

   Sie sollten bereits anhand der Anweisungen unter [Erstellen Sie eine Servicerolle (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli) eine Service-Rolle erstellt haben. Wie Sie den ARN der Service-Rolle abrufen können, erfahren Sie unter [Rufen Sie die Servicerolle ARN (CLI) ab](getting-started-create-service-role.md#getting-started-get-service-role-cli).

1. Nachdem Sie die Dienstrolle ARN haben, rufen Sie den **create-deployment-group** Befehl auf, um eine Bereitstellungsgruppe mit dem Namen zu erstellen**WordPress\$1DepGroup**, die der genannten Anwendung zugeordnet ist. Verwenden Sie dazu das Amazon EC2-Tag mit dem Namen **CodeDeployDemo** und die Bereitstellungskonfiguration mit dem Namen**CodeDeployDefault.OneAtATime**: **WordPress\$1App**

   ```
   aws deploy create-deployment-group \
     --application-name WordPress_App \
     --deployment-group-name WordPress_DepGroup \
     --deployment-config-name CodeDeployDefault.OneAtATime \
     --ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE \
     --service-role-arn serviceRoleARN
   ```

   
**Anmerkung**  
Der [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)Befehl bietet Unterstützung für die Erstellung von Triggern, die zum Senden von Amazon SNS SNS-Benachrichtigungen an Themenabonnenten über bestimmte Ereignisse in Bereitstellungen und Instances führen. Der Befehl unterstützt auch Optionen für das automatische Rollback von Bereitstellungen und die Einrichtung von Alarmen, um Bereitstellungen zu beenden, wenn die Überwachungsschwellenwerte in CloudWatch Amazon-Alarmen erreicht werden. Befehle für diese Aktionen sind in diesem Tutorial nicht enthalten.

1. Bevor Sie eine Bereitstellung erstellen, muss der CodeDeploy Agent auf den Instances in Ihrer Bereitstellungsgruppe installiert sein. Sie können den Agenten über die Befehlszeile mit folgendem Befehl mit AWS Systems Manager installieren:

   ```
   aws ssm create-association \
     --name AWS-ConfigureAWSPackage \
     --targets Key=tag:Name,Values=CodeDeployDemo \
     --parameters action=Install,name=AWSCodeDeployAgent \
     --schedule-expression "cron(0 2 ? * SUN *)"
   ```

   Dieser Befehl erstellt eine Verknüpfung in Systems Manager State Manager, die den CodeDeploy Agenten installiert und dann versucht, ihn jeden Sonntagmorgen um 2:00 Uhr zu aktualisieren. Weitere Informationen zum CodeDeploy Agenten finden Sie unter [Mit dem CodeDeploy Agenten arbeiten](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html). Weitere Informationen zu Systems Manager finden Sie unter [Was ist AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).

1. Rufen Sie nun den Befehl **create-deployment** zum Erstellen einer Bereitstellung auf, die der Anwendung **WordPress\$1App**, der Bereitstellungskonfiguration **CodeDeployDefault.OneAtATime** und der Bereitstellungsgruppe **WordPress\$1DepGroup** zugeordnet ist, unter Verwendung der Anwendungrevision **WordPressApp.zip** im Bucket **amzn-s3-demo-bucket**:

   ```
   aws deploy create-deployment \
     --application-name WordPress_App \
     --deployment-config-name CodeDeployDefault.OneAtATime \
     --deployment-group-name WordPress_DepGroup \
     --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
   ```

### Mit der Konsole stellen Sie die Anwendungsrevision wie folgt bereit:
<a name="tutorials-wordpress-deploy-application-create-deployment-console"></a>

1. Bevor Sie die CodeDeploy Konsole zum Bereitstellen Ihrer Anwendungsrevision verwenden, benötigen Sie einen ARN für die Servicerolle. Eine Servicerolle ist eine IAM-Rolle, die einem Dienst die Erlaubnis erteilt, in Ihrem Namen zu handeln. In diesem Fall erteilt die Service-Rolle die CodeDeploy Erlaubnis, auf Ihre Amazon EC2 EC2-Instances zuzugreifen, um deren Amazon EC2 EC2-Instance-Tags zu erweitern (zu lesen).

   Sie sollten bereits anhand der Anweisungen unter [Erstellen Sie eine Servicerolle (Konsole)](getting-started-create-service-role.md#getting-started-create-service-role-console) eine Service-Rolle erstellt haben. Wie Sie den ARN der Service-Rolle abrufen können, erfahren Sie unter [Rufen Sie die Servicerolle ARN ab (Konsole)](getting-started-create-service-role.md#getting-started-get-service-role-console).

1. Nachdem Sie den ARN haben, verwenden Sie die CodeDeploy Konsole, um die Revision Ihrer Anwendung bereitzustellen:

   Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

1. Wählen Sie in der Liste der Anwendungen die Option **WordPress\$1App** aus.

1. Wählen Sie auf der Registerkarte **Deployment groups (Bereitstellungsgruppen)**, die Option **Create deployment group (Bereitstellungsgruppe erstellen)** aus.

1. Geben Sie unter **Deployment group name (Name der Bereitstellungsgruppe)** **WordPress\$1DepGroup** ein.

1. Wählen Sie unter **Deployment type** die Option **In-place deployment**.

1. Wählen Sie unter **Umgebungskonfiguration** **Amazon EC2 EC2-Instances** aus.

1. Behalten Sie **unter Agentenkonfiguration mit AWS Systems Manager** die Standardeinstellungen bei.

1. Geben Sie für **Key (Schlüssel)** **Name** ein.

1. Geben Sie unter **Value (Wert)** **CodeDeployDemo** ein.
**Anmerkung**  
Nach der Eingabe sollte unter **Passende Instances** eine **1** erscheinen**CodeDeployDemo**, um zu bestätigen, dass eine passende Amazon EC2 EC2-Instance CodeDeploy gefunden wurde.

1. **Wählen Sie in der **Bereitstellungskonfiguration** die OptionCodeDeployDefault. OneAtATime**.

1. Wählen Sie in der Dropdownliste **Service role ARN (Servicerolle-ARN)** den ARN der Servicerolle aus und klicken Sie dann auf **Create deployment group (Bereitstellungsgruppe erstellen)**.

1. Wählen Sie **Create deployment**.

1. Wählen Sie unter **Deployment group (Bereitstellungsgruppe)** die Option **WordPress\$1DepGroup** aus.

1. Wählen Sie neben **Repository-Typ** die Option **Meine Anwendung ist in Amazon S3 gespeichert** aus. Geben Sie **unter Revisionsort** den Speicherort der Version der WordPress Beispielanwendung ein, die Sie zuvor auf Amazon S3 hochgeladen haben. Ermitteln Sie den Speicherort wie folgt:

   1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

   1. Wählen Sie in der Liste der Buckets **amzn-s3-demo-bucket** aus (oder den Namen des Buckets, in den Sie Ihre Anwendungsrevision hochgeladen haben). 

   1. **Wählen Sie in der Liste der Objekte die Datei .zip aus. WordPressApp**

   1. Kopieren Sie auf der Registerkarte **Overview** (Übersicht) den Wert des Feldes **Link** (Link) in die Zwischenablage.

      Er kann wie folgt aussehen:

      **https://s3.amazonaws.com/amzn-s3-demo-bucket/WordPressApp.zip**

   1. Kehren Sie zur CodeDeploy Konsole zurück, und fügen Sie in **Revisionsort** den Feldwert **Link** ein.

1. Falls in der Liste **File type** (Dateityp) die Meldung angezeigt wird, dass der Dateityp nicht erkannt wurde, wählen Sie **.zip** aus der Liste der Dateitypen aus.

1. (Optional) Geben Sie einen Kommentar in dem Feld **Deployment description** ein. 

1. **Erweitern Sie **Deployment Group Overrides** und wählen Sie CodeDeployDefault unter **Deployment-Konfiguration** die Option aus. OneAtATime**.

1. Klicken Sie auf **Start deployment (Bereitstellung starten)**. Auf der Seite **Deployments** werden nun Informationen zu der neu erstellten Bereitstellung angezeigt.

## Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler
<a name="tutorials-wordpress-deploy-application-monitor"></a>

Verwenden Sie die Konsole AWS CLI oder die Konsole, um Ihre Bereitstellung zu überwachen und Fehler zu beheben.

**Topics**
+ [Über die CLI können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:](#tutorials-wordpress-deploy-application-monitor-cli)
+ [Über die Konsole können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:](#tutorials-wordpress-deploy-application-monitor-console)

### Über die CLI können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:
<a name="tutorials-wordpress-deploy-application-monitor-cli"></a>

1. Fordern Sie die ID der Bereitstellung an, indem Sie den Befehl **list-deployments** für die Anwendung **WordPress\$1App** und die Bereitstellungsgruppe **WordPress\$1DepGroup** aufrufen:

   ```
   aws deploy list-deployments --application-name WordPress_App --deployment-group-name WordPress_DepGroup --query 'deployments' --output text
   ```

1. Rufen Sie den Befehl **get-deployment** mit der Bereitstellungs-ID auf:

   ```
   aws deploy get-deployment --deployment-id deploymentID --query 'deploymentInfo.status' --output text
   ```

1. Der Befehl gibt den allgemeinen Status der Bereitstellung zurück. Wurde die Bereitstellung erfolgreich abgeschlossen, lautet der Wert `Succeeded`.

   Wird als allgemeiner Status `Failed` zurückgegeben, können Sie zur Problembehebung Befehle wie [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) und [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) aufrufen. Weitere Optionen für die Problembehebung finden Sie unter [Analysieren von Protokolldateien zur Untersuchung von Bereitstellungsfehlern auf Instances](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).

### Über die Konsole können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:
<a name="tutorials-wordpress-deploy-application-monitor-console"></a>

Auf der Seite **Bereitstellungen** in der CodeDeploy Konsole können Sie den Status Ihrer Bereitstellung in der Spalte **Status** überwachen.

Weitere Informationen zu Ihrer Bereitstellung können Sie wie nachfolgend beschrieben abrufen. Dies ist insbesondere nützlich, falls in der Spalte **Status** ein anderer Wert als **Succeeded** steht:

1. Wählen Sie in der Tabelle **Deployments (Bereitstellungen)** den Namen der Bereitstellung aus. Falls eine Bereitstellung fehlschlägt, wird eine Meldung mit dem Grund des Fehlschlagens angezeigt.

1. Unter **Instance activity (Instance-Aktivität)** werden weitere Informationen zur Bereitstellung angezeigt. Wenn eine Bereitstellung fehlschlägt, können Sie möglicherweise feststellen, auf welchen Amazon EC2 EC2-Instances und in welchem Schritt die Bereitstellung fehlgeschlagen ist.

1. Für eine weitergehende Problembehebung können Sie wie unter [Instanzdetails anzeigen mit CodeDeploy](instances-view-details.md) beschrieben vorgehen. Sie können auch die Bereitstellungsprotokolldateien auf einer Amazon EC2 EC2-Instance analysieren. Weitere Informationen finden Sie unter [Analysieren von Protokolldateien zur Untersuchung von Bereitstellungsfehlern auf Instances](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).

## Überprüfen Sie Ihre Bereitstellung
<a name="tutorials-wordpress-deploy-application-verify-deployment"></a>

Stellen Sie nach erfolgreicher Bereitstellung sicher, dass Ihre WordPress Installation funktioniert. Verwenden Sie die öffentliche DNS-Adresse der Amazon EC2 EC2-Instance, gefolgt von`/WordPress`, um Ihre Site in einem Webbrowser anzuzeigen. (Um den öffentlichen DNS-Wert abzurufen, wählen Sie in der Amazon EC2 EC2-Konsole die Amazon EC2 EC2-Instance aus und suchen Sie auf der Registerkarte **Beschreibung** nach dem Wert von **Public DNS**.)

Wenn die öffentliche DNS-Adresse Ihrer Amazon EC2 EC2-Instance beispielsweise lautet**ec2-01-234-567-890.compute-1.amazonaws.com**, würden Sie die folgende URL verwenden:

```
http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress
```

Wenn Sie die Website in Ihrem Browser aufrufen, sollten Sie eine WordPress Willkommensseite sehen, die der folgenden ähnelt:

![\[WordPress Willkommensseite\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/WordPress-Welcome-Page-013118.png)


 Wenn Ihrer Amazon EC2 EC2-Instance keine Regel für eingehenden HTTP-Datenverkehr zur Sicherheitsgruppe hinzugefügt wurde, wird die WordPress Willkommensseite nicht angezeigt. Wenn Sie eine Meldung sehen, die besagt, dass der Remote-Server nicht reagiert, stellen Sie sicher, dass die Sicherheitsgruppe für Ihre Amazon EC2 EC2-Instance die eingehende Regel hat. Weitere Informationen finden Sie unter [Fügen Sie eine Regel für eingehenden Datenverkehr hinzu, die HTTP-Verkehr zu Ihrer Amazon Linux- oder RHEL Amazon EC2 EC2-Instance zulässtFügen Sie eine Regel für eingehenden Datenverkehr hinzu, die HTTP-Verkehr zu Ihrer Windows Server Amazon EC2 EC2-Instance zulässt](tutorials-wordpress-launch-instance.md#tutorials-wordpress-launch-instance-add-inbound-rule). 

# Schritt 5: Aktualisieren Sie Ihre WordPress Anwendung und stellen Sie sie erneut bereit
<a name="tutorials-wordpress-update-and-redeploy-application"></a>

Nachdem Sie Ihre Anwendungsversion erfolgreich bereitgestellt haben, aktualisieren Sie den WordPress Code auf dem Entwicklungscomputer und verwenden Sie ihn dann, CodeDeploy um die Site erneut bereitzustellen. Danach sollten Sie die Codeänderungen auf der Amazon EC2 EC2-Instance sehen.

**Topics**
+ [Richten Sie die Site ein WordPress](#tutorials-wordpress-update-and-redeploy-application-configure-and-install)
+ [Ändern Sie die Site](#tutorials-wordpress-update-and-redeploy-application-modify-code)
+ [Stellen Sie die Site erneut bereit](#tutorials-wordpress-update-and-redeploy-application-deploy-updates)

## Richten Sie die Site ein WordPress
<a name="tutorials-wordpress-update-and-redeploy-application-configure-and-install"></a>

Um die Auswirkungen der Codeänderung zu sehen, beenden Sie die Einrichtung der WordPress Site, sodass Sie über eine voll funktionsfähige Installation verfügen.

1. Geben Sie die URL Ihrer Site in Ihren Webbrowser ein. Die URL ist die öffentliche DNS-Adresse der Amazon EC2 EC2-Instance plus eine `/WordPress` Erweiterung. Für diese WordPress Beispiel-Site (und die öffentliche DNS-Adresse der Amazon EC2 EC2-Instance) lautet die URL. **http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress**

1. Wenn Sie die Site noch nicht eingerichtet haben, wird die WordPress Standard-Willkommensseite angezeigt. Wählen Sie **Let's go\$1** (Los geht's\$1).

1. Geben Sie auf der Seite Datenbankkonfiguration die folgenden Werte ein, um die Standard-MySQL-Datenbank zu nutzen:
   + **Datenbankname**: **test**
   + **Benutzername**: **root**
   + **Passwort**: Lassen Sie das Feld leer.
   + **Datenbank-Host**: **localhost**
   + **Tabellenpräfix**: **wp\$1**

   Wählen Sie **Submit**, um die Datenbank einzurichten.

1. Fahren Sie mit der Einrichtung der Website fort. Geben Sie auf der **Willkommensseite** alle gewünschten Werte ein und wählen Sie **Installieren WordPress**. Wenn die Installation abgeschlossen ist, können Sie sich bei Ihrem Dashboard anmelden.

**Wichtig**  
 Während der Bereitstellung der WordPress Anwendung hat das **change\$1permissions.sh** Skript die Berechtigungen für den `/tmp/WordPress` Ordner aktualisiert, sodass jeder in den Ordner schreiben kann. Nun ist eine gute Gelegenheit, den folgenden Befehl auszuführen, um die Berechtigungen so einzuschränken, dass nur Sie als Eigentümer darin schreiben können:  

```
chmod -R 755 /var/www/html/WordPress
```

## Ändern Sie die Site
<a name="tutorials-wordpress-update-and-redeploy-application-modify-code"></a>

Um die WordPress Site zu ändern, wechseln Sie in den Ordner der Anwendung auf Ihrem Entwicklungscomputer:

```
cd /tmp/WordPress
```

Verwenden Sie zur Modifizierung einiger der Farben der Website in der Datei `wp-content/themes/twentyfifteen/style.css` einen Texteditor oder **sed**, um `#fff` in `#768331` zu ändern. 

Bei Linux oder anderen Systemen mit GNU **sed** verwenden Sie:

```
sed -i 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```

Bei macOS, Unix oder anderen Systemen mit BSD **sed** verwenden Sie:

```
sed -i '' 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```

## Stellen Sie die Site erneut bereit
<a name="tutorials-wordpress-update-and-redeploy-application-deploy-updates"></a>

Nachdem Sie den Code der Site geändert haben, verwenden Sie Amazon S3 und CodeDeploy stellen Sie die Site erneut bereit.

Bündeln Sie die Änderungen und laden Sie sie auf Amazon S3 hoch, wie unter beschrieben[Bündeln Sie die Dateien der Anwendung in einer einzigen Archivdatei und übertragen Sie die Archivdatei per Push](tutorials-wordpress-upload-application.md#tutorials-wordpress-upload-application-bundle-and-push-archive). (Wenn Sie diese Anweisungen befolgen, müssen Sie keine Anwendung erstellen.) Geben Sie der neuen Revision denselben Schlüssel wie zuvor (**WordPressApp.zip**). Laden Sie es in denselben Amazon S3 S3-Bucket hoch, den Sie zuvor erstellt haben (z. B.**amzn-s3-demo-bucket**).

Verwenden Sie die AWS CLI, die CodeDeploy Konsole oder die, CodeDeploy APIs um die Site erneut bereitzustellen.

**Topics**
+ [Erneutes Bereitstellen der Website (CLI)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-cli)
+ [Erneutes Bereitstellen der Website (Konsole)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-console)

### Erneutes Bereitstellen der Website (CLI)
<a name="tutorials-wordpress-update-and-redeploy-application-deploy-updates-cli"></a>

Rufen Sie den Befehl **create-deployment** auf, um eine auf der neu hochgeladenen Revision basierende Bereitstellung zu erstellen. Verwenden Sie die Anwendung mit dem Namen **WordPress\$1App**, die Bereitstellungskonfiguration mit dem Namen **CodeDeployDefault.OneAtATime**, die Bereitstellungsgruppe mit dem Namen **WordPress\$1DepGroup** und die Revision mit dem Namen **WordPressApp.zip** im Bucket mit dem Namen **amzn-s3-demo-bucket**:

```
 aws deploy create-deployment \
  --application-name WordPress_App \
  --deployment-config-name CodeDeployDefault.OneAtATime \
  --deployment-group-name WordPress_DepGroup \  
  --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```

Sie können den Status der Bereitstellung wie in [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor) beschrieben überprüfen.

Nachdem CodeDeploy Sie die Site erneut bereitgestellt haben, rufen Sie die Site erneut in Ihrem Webbrowser auf, um zu überprüfen, ob die Farben geändert wurden. (Sie müssen möglicherweise Ihren Browser aktualisieren.) Wenn die Farben geändert wurden, herzlichen Glückwunsch\$1 Sie haben Ihre Website erfolgreich geändert und erneut bereitgestellt\$1

### Erneutes Bereitstellen der Website (Konsole)
<a name="tutorials-wordpress-update-and-redeploy-application-deploy-updates-console"></a>

1. [Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter https://console.aws.amazon.com /codedeploy.](https://console.aws.amazon.com/codedeploy)
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

1. Wählen Sie in der Liste der Anwendungen die Option **WordPress\$1App** aus.

1. Wählen Sie auf der Registerkarte **Deployment groups (Bereitstellungsgruppen)** die Option **WordPress\$1DepGroup**.

1. Wählen Sie **Create deployment**. 

1. Auf der Seite **Create deployment**:

   1. Wählen Sie unter **Deployment group (Bereitstellungsgruppe)** die Option **WordPress\$1DepGroup** aus.

   1. Wählen Sie im Bereich **Repository-Typ** die Option **Meine Anwendung ist in Amazon S3 gespeichert** aus und kopieren Sie dann den Amazon S3 S3-Link Ihrer Revision in das Feld **Speicherort der Revision**. Ermitteln des Link-Wertes: 

      1. In einer separaten Browser-Registerkarte:

         Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

          Navigieren Sie zu **amzn-s3-demo-bucket**, öffnen Sie es und wählen Sie dann Ihre Revision aus. **WordPressApp.zip** 

      1.  Wenn der **Eigenschaftenbereich** in der Amazon S3 S3-Konsole nicht sichtbar ist, wählen Sie die Schaltfläche **Eigenschaften**. 

      1.  Kopieren Sie im **Eigenschaftenbereich** den Wert des **Link-Felds** in das Feld **Revisionsort** in der CodeDeploy Konsole. 

   1. Wenn eine Meldung angezeigt wird, die besagt, dass der Dateityp nicht erkannt werden konnte, wählen Sie **.zip**. 

   1. Lassen Sie das Feld **Deployment description** leer.

   1. **Erweitern Sie **Deployment Group Overrides** und wählen Sie CodeDeployDefault unter **Deployment-Konfiguration** die Option aus. OneAtATime**.

   1. Klicken Sie auf **Start deployment (Bereitstellung starten)**. Auf der Seite **Deployments** werden nun Informationen zu der neu erstellten Bereitstellung angezeigt.

   1. Sie können den Status der Bereitstellung wie in [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor) beschrieben überprüfen.

      Nachdem CodeDeploy Sie die Site erneut bereitgestellt haben, rufen Sie die Site erneut in Ihrem Webbrowser auf, um zu überprüfen, ob die Farben geändert wurden. (Sie müssen möglicherweise Ihren Browser aktualisieren.) Wenn die Farben geändert wurden, herzlichen Glückwunsch\$1 Sie haben Ihre Website erfolgreich geändert und erneut bereitgestellt\$1

# Schritt 6: Bereinigen Sie Ihre WordPress Anwendung und die zugehörigen Ressourcen
<a name="tutorials-wordpress-clean-up"></a>

Sie haben den WordPress Code jetzt erfolgreich aktualisiert und die Site erneut bereitgestellt. Um laufende Gebühren für die Ressourcen, die Sie für dieses Tutorial erstellt haben, zu vermeiden, sollten Sie Folgendes löschen:
+ Alle CloudFormation Stacks (oder beenden Sie alle Amazon EC2 EC2-Instances, falls Sie sie außerhalb von CloudFormation erstellt haben).
+ Alle Amazon S3 S3-Buckets.
+ Die Anwendung `WordPress_App` in CodeDeploy.
+ Die AWS Systems Manager State Manager-Zuordnung für den CodeDeploy Agenten.

Sie können Amazon S3 AWS CLI CloudFormation, Amazon EC2 und die CodeDeploy Konsolen oder die verwenden, AWS APIs um die Bereinigung durchzuführen.

**Topics**
+ [So bereinigen Sie die Ressourcen (CLI):](#tutorials-wordpress-clean-up-cli)
+ [So bereinigen Sie Ressourcen (Konsole):](#tutorials-wordpress-clean-up-console)
+ [Als nächstes](#tutorials-wordpress-clean-up-whats-next)

## So bereinigen Sie die Ressourcen (CLI):
<a name="tutorials-wordpress-clean-up-cli"></a>

1. Wenn Sie unsere CloudFormation Vorlage für dieses Tutorial verwendet haben, rufen Sie den **delete-stack** Befehl für den genannten Stack auf. **CodeDeployDemoStack** Dadurch werden alle zugehörigen Amazon EC2 EC2-Instances beendet und alle zugehörigen IAM-Rollen gelöscht, die der Stack erstellt hat:

   ```
   aws cloudformation delete-stack --stack-name CodeDeployDemoStack
   ```

1. Um den Amazon S3 S3-Bucket zu löschen, rufen Sie den **rm** Befehl mit dem **--recursive** Schalter für den genannten Bucket auf**amzn-s3-demo-bucket**. So löschen Sie den Bucket und alle Objekte im Bucket:

   ```
   aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
   ```

1. Um die Anwendung `WordPress_App` zu löschen, rufen Sie den Befehl **delete-application** auf. Damit werden auch alle zugehörigen Bereitstellungsgruppen-Datensätze und die Bereitstellungsdatensätze für die Anwendung gelöscht:

   ```
   aws deploy delete-application --application-name WordPress_App
   ```

1. Rufen Sie den **delete-association** Befehl auf, um die Systems Manager State Manager-Zuordnung zu löschen.

   ```
   aws ssm delete-association --assocation-id association-id
   ```

   Sie können den abrufen, *association-id* indem Sie den **describe-association** Befehl aufrufen.

   ```
   aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
   ```

Wenn Sie den CloudFormation Stack für dieses Tutorial nicht verwendet haben, rufen Sie den **terminate-instances** Befehl auf, um alle Amazon EC2 EC2-Instances zu beenden, die Sie manuell erstellt haben. Geben Sie die ID der Amazon EC2 EC2-Instance an, die beendet werden soll:

```
aws ec2 terminate-instances --instance-ids instanceId
```

## So bereinigen Sie Ressourcen (Konsole):
<a name="tutorials-wordpress-clean-up-console"></a>

Wenn Sie unsere CloudFormation Vorlage für dieses Tutorial verwendet haben, löschen Sie den zugehörigen CloudFormation Stack.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Geben Sie im Feld **Filter** den CloudFormation Stacknamen ein, den Sie zuvor erstellt haben (z. B.**CodeDeployDemoStack**).

1. Aktivieren Sie das Kontrollkästchen neben dem Stack-Namen. Wählen Sie im Menü **Actions** die Option **Delete Stack**.

   CloudFormation löscht den Stack, beendet alle zugehörigen Amazon EC2 EC2-Instances und löscht alle zugehörigen IAM-Rollen.

So beenden Sie Amazon EC2 EC2-Instances, die Sie außerhalb eines CloudFormation Stacks erstellt haben:

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie in der Liste **INSTANCES** die Option **Instances**.

1. Geben Sie in das Suchfeld den Namen der Amazon EC2 EC2-Instance ein, die Sie beenden möchten (z. B.**CodeDeployDemo**), und drücken Sie dann die Eingabetaste.

1. Wählen Sie den Namen der Amazon EC2 EC2-Instanz.

1. Zeigen Sie im Menü **Actions** auf **Instance State**, und wählen Sie dann **Terminate**. Wählen Sie bei Aufforderung **Yes, Terminate**. 

Wiederholen Sie diese Schritte für jede Instance.

Um den Amazon S3 S3-Bucket zu löschen:

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Suchen Sie in der Liste der Buckets nach dem Namen des Amazon S3 S3-Buckets, den Sie zuvor erstellt haben, und wählen Sie ihn aus (z. B.**amzn-s3-demo-bucket**).

1. Bevor Sie einen Bucket löschen können, müssen Sie zunächst seinen Inhalt löschen. Wählen Sie alle Dateien im Bucket aus, z. B. **WordPressApp.zip**. Wählen Sie im Menü **Actions** die Option **Delete**. Wenn Sie zum Bestätigen des Löschvorgangs aufgefordert werden, wählen Sie **OK**. 

1. Nachdem der Bucket leer ist, kann er gelöscht werden. Wählen Sie in der Bucket-Liste die Zeile mit dem Bucket aus (aber nicht den Namen des Buckets). Wählen Sie **Delete bucket** und bei der Aufforderung zum Bestätigen **OK**. 

Um die `WordPress_App` Anwendung zu löschen von CodeDeploy:

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

1. Wählen Sie in der Liste der Anwendungen **WordPress\$1App** aus.

1. Wählen Sie auf der Seite **Application details** die Option **Delete application**.

1. Geben Sie bei Aufforderung den Namen der Anwendung ein, um das Löschen zu bestätigen, und klicken Sie auf **Delete (Löschen)**. 

So löschen Sie die Systems Manager State Manager-Zuordnung:

1. Öffnen Sie die AWS Systems Manager Konsole unter https://console.aws.amazon.com /systems-manager.

1. Wählen Sie im Navigationsbereich **Statusmanager** aus.

1. Wählen Sie die Verknüpfung aus, die Sie erstellt haben, und wählen Sie **Delete (Löschen)** aus.

## Als nächstes
<a name="tutorials-wordpress-clean-up-whats-next"></a>

Glückwunsch, dass Sie hier angekommen sind\$1 Sie haben erfolgreich eine CodeDeploy-Bereitstellung abgeschlossen, dann den Code Ihrer Site aktualisiert und ihn erneut bereitgestellt. 

# Tutorial: Bereite ein „Hallo, Welt\$1“ vor Anwendung mit CodeDeploy (Windows Server)
<a name="tutorials-windows"></a>

In diesem Tutorial stellen Sie eine einzelne Webseite auf einer einzelnen Windows Server-Amazon EC2-Instance bereit, auf der Internet Information Services (IIS) als Webserver ausgeführt wird. Auf dieser Webseite wird ein einfaches „Hallo, Welt\$1“ angezeigt message.

Nicht das, wonach Sie gesucht haben?
+ Um stattdessen die Bereitstellung auf einer Amazon Linux- oder Red Hat Enterprise Linux (RHEL) Amazon EC2 EC2-Instance zu üben, siehe. [Tutorial: Bereitstellung WordPress auf einer Amazon EC2 EC2-Instance (Amazon Linux oder Red Hat Enterprise Linux und Linux, macOS oder Unix)](tutorials-wordpress.md)
+ Informationen zum Bereitstellen auf einer lokalen Instance finden Sie unter [Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).

Die Schritte in diesem Tutorial gelten für Windows. Obwohl Sie die meisten dieser Schritte auf einem lokalen Computer unter Linux, macOS oder Unix ausführen können, müssen Sie diejenigen anpassen, die Windows-basierte Verzeichnispfade abdecken, wie z. `c:\temp` Wenn Sie eine Verbindung zur Amazon EC2 EC2-Instance herstellen möchten, benötigen Sie außerdem eine Client-Anwendung, die über das Remote Desktop Protocol (RDP) eine Verbindung zur Amazon EC2 EC2-Instance herstellen kann, auf der Windows Server ausgeführt wird. (Windows bietet standardmäßig eine RDP-Verbindungs-Client-Anwendung.)

Bevor Sie mit diesem Tutorial beginnen, müssen Sie die Voraussetzungen unter erfüllen[Erste Schritte mit CodeDeploy](getting-started-codedeploy.md), einschließlich der Konfiguration Ihres Benutzers, der Installation oder Aktualisierung von und der AWS CLI Erstellung eines IAM-Instance-Profils und einer Servicerolle.

**Topics**
+ [Schritt 1: Starten Sie eine Windows Server Amazon EC2 EC2-Instance](tutorials-windows-launch-instance.md)
+ [Schritt 2: Konfigurieren Sie Ihren Quellinhalt für die Bereitstellung auf der Windows Server Amazon EC2 EC2-Instance](tutorials-windows-configure-content.md)
+ [Schritt 3: Lade dein „Hallo, Welt\$1“ hoch Anwendung auf Amazon S3](tutorials-windows-upload-application.md)
+ [Schritt 4: Stellen Sie Ihre Hello World-Anwendung bereit](tutorials-windows-deploy-application.md)
+ [Schritt 5: Aktualisieren Sie Ihr „Hallo, Welt\$1“ und stellen Sie es erneut bereit Anwendung](tutorials-windows-update-and-redeploy-application.md)
+ [Schritt 6: Räumen Sie Ihr „Hallo, Welt\$1“ auf Anwendung und zugehörige Ressourcen](tutorials-windows-clean-up.md)

# Schritt 1: Starten Sie eine Windows Server Amazon EC2 EC2-Instance
<a name="tutorials-windows-launch-instance"></a>

Um die Hello World-Anwendung mit bereitzustellen CodeDeploy, benötigen Sie eine Amazon EC2 EC2-Instance, auf der Windows Server ausgeführt wird.

Folgen Sie den Anweisungen in [Erstellen Sie eine Amazon EC2 EC2-Instance für CodeDeploy](instances-ec2-create.md). Wenn Sie bereit sind, der Instance ein Amazon EC2 EC2-Instance-Tag zuzuweisen, geben Sie unbedingt den Tag-Schlüssel von **Name** und den Tag-Wert von **CodeDeployDemo** an. (Wenn Sie einen anderen Tag-Schlüssel oder Tag-Wert angeben, dann könnten die Anweisungen in [Schritt 4: Stellen Sie Ihre Hello World-Anwendung bereit](tutorials-windows-deploy-application.md) zu unerwarteten Ergebnissen führen.)

Nachdem Sie die Amazon EC2 EC2-Instance gestartet haben, kehren Sie zu dieser Seite zurück und fahren Sie mit dem nächsten Abschnitt fort. Fahren Sie nicht mit [Erstellen Sie eine Anwendung mit CodeDeploy](applications-create.md) als nächsten Schritt fort.

## Connect zu Ihrer Amazon EC2 EC2-Instance her
<a name="tutorials-windows-launch-instance-connect"></a>

Nachdem Ihre Amazon EC2 EC2-Instance gestartet wurde, folgen Sie diesen Anweisungen, um zu üben, wie Sie sich mit ihr verbinden. 

**Anmerkung**  
In dieser Anleitung wird davon ausgegangen, dass Windows und die Windows Desktop Connection-Clientanwendung ausgeführt werden. Weitere Informationen finden Sie unter [Herstellen einer Verbindung zu Ihrer Windows-Instance mithilfe von RDP](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/connecting_to_windows_instance.html). Unter Umständen müssen Sie diese Anweisungen für andere Betriebssysteme oder andere Clientanwendungen für RDP-Verbindungen anpassen.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie im Navigationsbereich unter **Instances** die Option **Instances**. 

1. Navigieren Sie zu Ihrer Windows Server-Instance und wählen Sie sie in der Liste aus.

1. Wählen Sie **Connect** aus.

1. Wählen Sie **Get Password (Passwort abrufen)** und wählen Sie dann **Choose File (Datei wählen)**.

1. **Suchen Sie die Amazon EC2-Instance-Schlüsselpaardatei, die mit der Amazon EC2-Instance von Windows Server verknüpft ist, wählen Sie sie aus, und wählen Sie dann Öffnen aus.**

1. Klicken Sie auf **Decrypt Password**. Notieren Sie sich das angezeigte Passwort. Sie benötigen ihn in Schritt 10.

1. Wählen Sie **Download Remote Desktop File**, und öffnen Sie dann die Datei.

1. Wenn Sie zum Verbinden aufgefordert werden, obwohl der Herausgeber der Remote-Verbindung nicht identifiziert werden kann, fahren Sie fort.

1. Geben Sie das Passwort ein, das Sie sich in Schritt 7 notiert haben, und fahren Sie dann fort. (Wenn Ihre Clientanwendung für die RDP-Verbindung Sie zur Eingabe eines Benutzernamens auffordert, geben Sie **Administrator** ein.)

1. Wenn Sie zum Verbinden aufgefordert werden, obwohl die Identität des Remotecomputers nicht überprüft werden konnte, fahren Sie fort. 

1. Nachdem Sie eine Verbindung hergestellt haben, wird der Desktop der Amazon EC2 EC2-Instance angezeigt, auf der Windows Server ausgeführt wird.

1. Sie können jetzt die Verbindung zur Amazon EC2 EC2-Instance trennen.
**Warnung**  
Stoppen oder beenden Sie die Instance nicht. Andernfalls CodeDeploy kann es nicht darauf bereitgestellt werden.

## Fügen Sie eine Regel für eingehenden Datenverkehr hinzu, die HTTP-Verkehr zu Ihrer Windows Server Amazon EC2 EC2-Instance zulässt
<a name="tutorials-windows-launch-instance-add-inbound-rule"></a>

Im nächsten Schritt wird bestätigt, dass Ihre Amazon EC2 EC2-Instance über einen offenen HTTP-Port verfügt, sodass Sie die bereitgestellte Webseite auf Ihrer Windows Server Amazon EC2 EC2-Instance in einem Browser sehen können. 

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie **Instances** und dann Ihre Instance aus. 

1. Wählen Sie auf der Registerkarte **Beschreibung** unter **Sicherheitsgruppen** die Option **Regeln für eingehenden Datenverkehr anzeigen** aus. 

   In Ihrer Sicherheitsgruppe sollte eine Liste mit Regeln wie die folgende angezeigt werden:

   ```
   Security Groups associated with i-1234567890abcdef0
    Ports     Protocol     Source     launch-wizard-N
    22        tcp          0.0.0.0/0          ✔
   ```

1.  Wählen Sie unter **Sicherheitsgruppen** die Sicherheitsgruppe für Ihre Amazon EC2 EC2-Instance aus. Ein möglicher Name ist **launch-wizard-*N***. Beim ***N*** im Namen handelt es sich um eine Nummer, die Ihrer Sicherheitsgruppe beim Erstellen Ihrer Instance zugewiesen wurde. 

    Wählen Sie die Registerkarte **Inbound (Eingehend)**. Wenn die Sicherheitsgruppe für Ihre Instance korrekt konfiguriert ist, sollte Ihnen eine Regel mit den folgenden Werten angezeigt werden: 
   + **Typ**: HTTP
   + **Protocol (Protokoll)**: TCP
   + **Portbereich**: 80
   + **Quelle**: 0.0.0.0/0

1.  Wenn Sie keine Regel mit diesen Werten sehen, gehen Sie wie unter [Regeln zu einer Sicherheitsgruppe hinzufügen beschrieben vor, um sie einer neuen Sicherheitsregel](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) hinzuzufügen. 

# Schritt 2: Konfigurieren Sie Ihren Quellinhalt für die Bereitstellung auf der Windows Server Amazon EC2 EC2-Instance
<a name="tutorials-windows-configure-content"></a>

Jetzt ist es an der Zeit, den Quellinhalt Ihrer Anwendung so zu konfigurieren, dass Sie etwas haben, das Sie auf der Amazon EC2 EC2-Instance bereitstellen können. In diesem Tutorial stellen Sie eine einzelne Webseite für die Amazon EC2 EC2-Instance bereit, auf der Windows Server ausgeführt wird, auf der Internet Information Services (IIS) als Webserver ausgeführt wird. Auf dieser Webseite wird ein einfaches „Hello, World\$1“ angezeigt message.

**Topics**
+ [Erstellen Sie die Webseite](#tutorials-windows-configure-content-download-code)
+ [Erstellen Sie ein Skript, um Ihre Anwendung auszuführen](#tutorials-windows-configure-content-create-scripts)
+ [Fügen Sie eine Anwendungsspezifikationsdatei hinzu](#tutorials-windows-configure-content-add-appspec-file)

## Erstellen Sie die Webseite
<a name="tutorials-windows-configure-content-download-code"></a>

1. Erstellen Sie ein Unterverzeichnis (Unterordner) mit dem Namen `HelloWorldApp` in Ihrem Ordner `c:\temp` und wechseln Sie dann zu diesem Ordner.

   ```
   mkdir c:\temp\HelloWorldApp
   cd c:\temp\HelloWorldApp
   ```
**Anmerkung**  
Sie müssen nicht den Standort `c:\temp` oder den Unterordnernamen `HelloWorldApp` verwenden. Wenn Sie einen anderen Standort oder einen anderen Unterordnernamen verwenden, müssen Sie diesen durchgehend im ganzen Tutorial verwenden.

1. Erstellen Sie mit einem Texteditor eine Datei in dem Ordner. Benennen Sie die Datei `index.html`.

   ```
   notepad index.html
   ```

1. Fügen Sie der Datei den folgendes HTML-Code hinzu und speichern Sie dann die Datei.

   ```
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
   <html>
   <head>
     <title>Hello, World!</title>
     <style>
       body {
         color: #ffffff;
         background-color: #0188cc;
         font-family: Arial, sans-serif;  
         font-size:14px;
       }
     </style>
   </head>
   <body>
     <div align="center"><h1>Hello, World!</h1></div>
     <div align="center"><h2>You have successfully deployed an application using CodeDeploy</h2></div>
     <div align="center">
       <p>What to do next? Take a look through the <a href="https://aws.amazon.com/codedeploy">CodeDeploy Documentation</a>.</p>
     </div>
   </body>
   </html>
   ```

## Erstellen Sie ein Skript, um Ihre Anwendung auszuführen
<a name="tutorials-windows-configure-content-create-scripts"></a>

Als Nächstes erstellen Sie ein Skript, mit dem der Webserver auf der Amazon EC2 EC2-Zielinstanz eingerichtet CodeDeploy wird.

1. Erstellen Sie mithilfe eines Texteditors eine weitere Datei im selben Unterordner, in dem die Datei `index.html` gespeichert ist. Benennen Sie die Datei `before-install.bat`.

   ```
   notepad before-install.bat
   ```

1. Fügen Sie den folgenden Stapelskriptcode zu der Datei hinzu und speichern Sie dann die Datei.

   ```
   REM Install Internet Information Server (IIS).
   c:\Windows\Sysnative\WindowsPowerShell\v1.0\powershell.exe -Command Import-Module -Name ServerManager
   c:\Windows\Sysnative\WindowsPowerShell\v1.0\powershell.exe -Command Install-WindowsFeature Web-Server
   ```

## Fügen Sie eine Anwendungsspezifikationsdatei hinzu
<a name="tutorials-windows-configure-content-add-appspec-file"></a>

Als Nächstes fügen Sie zusätzlich zur Webseite und zur AppSpec Batch-Skriptdatei eine Anwendungsspezifikationsdatei (Datei) hinzu. Die AppSpec Datei ist eine [YAML-formatierte](http://www.yaml.org) Datei, die verwendet wird, um: CodeDeploy 
+ Ordnen Sie die Quelldateien in Ihrer Anwendungsrevision den entsprechenden Zielen auf der Instance zu.
+ Angeben von Skripts, die während der Bereitstellung in der Instance ausgeführt werden.

Die AppSpec Datei muss benannt werden. `appspec.yml` Sie muss sich im Stammordner des Anwendungsquellcodes befinden.

1. Erstellen Sie im selben Unterordner, in dem die Dateien `index.html` und `before-install.bat` gespeichert sind, mit einem Texteditor eine weitere Datei. Benennen Sie die Datei `appspec.yml`.

   ```
   notepad appspec.yml
   ```

1. Fügen Sie der Datei den folgendes YAML-Code hinzu und speichern Sie dann die Datei.

   ```
   version: 0.0
   os: windows
   files:
     - source: \index.html
       destination: c:\inetpub\wwwroot
   hooks:
     BeforeInstall:
       - location: \before-install.bat
         timeout: 900
   ```

CodeDeploy verwendet diese AppSpec Datei, um die `index.html` Datei im Stammordner des Anwendungsquellcodes in den `c:\inetpub\wwwroot` Ordner auf der Amazon EC2 EC2-Zielinstanz zu kopieren. Führt während der Bereitstellung das `before-install.bat` Batch-Skript auf der Amazon EC2 EC2-Zielinstanz während des **BeforeInstall** Bereitstellungslebenszyklus aus. CodeDeploy Wenn die Ausführung dieses Skripts länger als 900 Sekunden (15 Minuten) dauert, CodeDeploy wird die Bereitstellung gestoppt und die Bereitstellung auf der Amazon EC2 EC2-Instance als fehlgeschlagen markiert.

Weitere Informationen zu diesen Einstellungen finden Sie in der [CodeDeploy AppSpec Dateiverweis](reference-appspec-file.md).

**Wichtig**  
Die Platzierung und Anzahl von Leerzeichen zwischen den einzelnen Elementen in dieser Datei ist wichtig. Wenn der Abstand falsch ist, CodeDeploy wird ein Fehler ausgelöst, der möglicherweise schwer zu debuggen ist. Weitere Informationen finden Sie unter [AppSpec Abstand zwischen den Dateien](reference-appspec-file.md#reference-appspec-file-spacing).

# Schritt 3: Lade dein „Hallo, Welt\$1“ hoch Anwendung auf Amazon S3
<a name="tutorials-windows-upload-application"></a>

Jetzt bereiten Sie Ihre Quellinhalte vor und laden sie an einen Ort hoch, von dem aus Sie sie bereitstellen CodeDeploy können. Die folgenden Anweisungen zeigen Ihnen, wie Sie einen Amazon S3 S3-Bucket bereitstellen, die Dateien der Anwendungsrevision für den Bucket vorbereiten, die Dateien der Revision bündeln und dann die Revision in den Bucket übertragen.

**Anmerkung**  
Obwohl dies in diesem Tutorial nicht behandelt wird, können Sie es verwenden, CodeDeploy um Anwendungen von GitHub Repositorys auf Instances bereitzustellen. Weitere Informationen finden Sie unter [Integrieren CodeDeploy mit GitHub](integrations-partners-github.md).

**Topics**
+ [Bereitstellen eines Amazon S3 S3-Buckets](#tutorials-windows-upload-application-create-s3-bucket)
+ [Bereiten Sie die Dateien der Anwendung für den Bucket vor](#tutorials-windows-upload-application-prepare-application-files)
+ [Bündeln Sie die Dateien der Anwendung in einer einzigen Archivdatei und übertragen Sie die Archivdatei per Push](#tutorials-windows-upload-application-bundle-and-push-archive)

## Bereitstellen eines Amazon S3 S3-Buckets
<a name="tutorials-windows-upload-application-create-s3-bucket"></a>

Erstellen Sie einen Speichercontainer oder *Bucket* in Amazon S3 — oder verwenden Sie einen vorhandenen Bucket. Stellen Sie sicher, dass Sie die Revision in den Bucket hochladen können und dass Amazon EC2 EC2-Instances, die in Bereitstellungen verwendet werden, die Revision aus dem Bucket herunterladen können.

Sie können die AWS CLI, die Amazon S3-Konsole oder Amazon S3 verwenden, APIs um einen Amazon S3 S3-Bucket zu erstellen. Sobald Sie den Bucket erstellt haben, müssen Sie ihm und Ihrem CodeDeploy-Benutzer Zugriffsberechtigungen erteilen.

**Anmerkung**  
Bucket-Namen müssen in Amazon S3 für alle AWS Konten eindeutig sein. Falls Sie **amzn-s3-demo-bucket** nicht verwenden können: Versuchen Sie es mit einem anderen Bucket-Namen wie **amzn-s3-demo-bucket**, gefolgt von einem Bindestrich und Ihren Initialen oder einem anderen eindeutigen Bezeichner. Anschließend müssen Sie überall im Tutorial **amzn-s3-demo-bucket** durch Ihren Bucket-Namen ersetzen.  
Der Amazon S3 S3-Bucket muss in derselben AWS Region erstellt werden, in der Ihre Amazon EC2 EC2-Ziel-Instances gestartet werden. Wenn Sie den Bucket beispielsweise in der Region USA Ost (Nord-Virginia) erstellen, müssen Ihre Amazon EC2 EC2-Ziel-Instances in der Region USA Ost (Nord-Virginia) gestartet werden.

**Topics**
+ [So erstellen Sie einen Amazon S3 S3-Bucket (CLI)](#tutorials-windows-upload-application-create-s3-bucket-cli)
+ [So erstellen Sie einen Amazon S3 S3-Bucket (Konsole)](#tutorials-windows-upload-application-create-s3-bucket-console)
+ [Erteilen Sie Berechtigungen für den Amazon S3 S3-Bucket und Ihr AWS Konto](#tutorials-windows-upload-application-create-s3-bucket-grant-permission)

### So erstellen Sie einen Amazon S3 S3-Bucket (CLI)
<a name="tutorials-windows-upload-application-create-s3-bucket-cli"></a>

Rufen Sie den **mb** Befehl auf, um einen Amazon S3 S3-Bucket mit dem Namen zu erstellen**amzn-s3-demo-bucket**:

```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```

### So erstellen Sie einen Amazon S3 S3-Bucket (Konsole)
<a name="tutorials-windows-upload-application-create-s3-bucket-console"></a>

1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie in der Amazon S3 S3-Konsole **Create Bucket** aus.

1. Geben Sie im Feld **Bucket name (Bucket-Name)** einen Namen für den Bucket ein.

1. Wählen Sie aus der Liste **Region** die Zielregion aus, und klicken Sie auf **Create (Erstellen)**.

### Erteilen Sie Berechtigungen für den Amazon S3 S3-Bucket und Ihr AWS Konto
<a name="tutorials-windows-upload-application-create-s3-bucket-grant-permission"></a>

Sie müssen über Berechtigungen zum Hochladen in den Amazon S3 S3-Bucket verfügen. Sie können diese Berechtigungen über eine Amazon S3 S3-Bucket-Richtlinie angeben. In der folgenden Amazon S3 S3-Bucket-Richtlinie ermöglicht die Verwendung des Platzhalterzeichens (\$1) dem AWS Konto `111122223333` beispielsweise das Hochladen von Dateien in ein beliebiges Verzeichnis im Amazon S3 S3-Bucket mit dem Namen`amzn-s3-demo-bucket`:

```
{
    "Statement": [
        {
            "Action": [
                "s3:PutObject"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "111122223333"
                ]
            }
        }
    ]
}
```

Informationen zur Anzeige Ihrer AWS Konto-ID [finden Sie unter Ihre AWS Konto-ID finden](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId).

Jetzt ist ein guter Zeitpunkt, um zu überprüfen, ob der Amazon S3 S3-Bucket Download-Anfragen von jeder teilnehmenden Amazon EC2 EC2-Instance zulässt. Sie können dies über eine Amazon S3 S3-Bucket-Richtlinie angeben. In der folgenden Amazon S3 S3-Bucket-Richtlinie ermöglicht die Verwendung des Platzhalterzeichens (\$1) beispielsweise jeder Amazon EC2 EC2-Instance mit einem angehängten IAM-Instance-Profil, das den ARN `arn:aws:iam::444455556666:role/CodeDeployDemo` enthält, Dateien aus einem beliebigen Verzeichnis im Amazon S3 S3-Bucket mit dem Namen herunterzuladen: `amzn-s3-demo-bucket`

```
{
    "Statement": [
        {
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "arn:aws:iam::444455556666:role/CodeDeployDemo"
                ]
            }
        }
    ]
}
```

Informationen zum Generieren und Anhängen einer Amazon S3 S3-Bucket-Richtlinie finden Sie unter [Beispiele für Bucket-Richtlinien](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).

Der CodeDeploy Administratorbenutzer, in dem Sie erstellt haben, [Schritt 1: Einrichtung](getting-started-setting-up.md) muss auch über die Berechtigung verfügen, die Revision in den Amazon S3 S3-Bucket hochzuladen. Eine Möglichkeit, dies zu spezifizieren, ist eine IAM-Richtlinie, die Sie dem Berechtigungssatz des Benutzers hinzufügen, oder einer IAM-Rolle (die Sie dem Benutzer zuweisen). Die folgende IAM-Richtlinie ermöglicht es dem Benutzer, Revisionen an einer beliebigen Stelle im Amazon S3 S3-Bucket mit dem Namen hochzuladen: `amzn-s3-demo-bucket`

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	   
  "Statement":[
    {
      "Effect":"Allow",
      "Action":["s3:PutObject"],
      "Resource":"arn:aws:s3:::amzn-s3-demo-bucket/*"
    }
  ]
}
```

------

*Informationen zum Erstellen einer IAM-Richtlinie finden Sie unter [Erstellen von IAM-Richtlinien im IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).* *Informationen zum Hinzufügen einer Richtlinie zu einem Berechtigungssatz finden Sie unter [Erstellen eines Berechtigungssatzes](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html) im AWS IAM Identity Center Benutzerhandbuch.*

## Bereiten Sie die Dateien der Anwendung für den Bucket vor
<a name="tutorials-windows-upload-application-prepare-application-files"></a>

Stellen Sie sicher, dass die Webseite, die AppSpec Datei und das Skript auf Ihrem Entwicklungscomputer wie folgt organisiert sind:

```
c:\
  |-- temp\
        |--HelloWorldApp\
             |-- appspec.yml
             |-- before-install.bat
             |-- index.html
```

## Bündeln Sie die Dateien der Anwendung in einer einzigen Archivdatei und übertragen Sie die Archivdatei per Push
<a name="tutorials-windows-upload-application-bundle-and-push-archive"></a>

Bündeln Sie die Dateien in einer Archivdatei (auch Anwendungs*revision* genannt).

**Anmerkung**  
Möglicherweise werden Ihnen für die Speicherung von Objekten in einem Bucket und die Übertragung von Anwendungsrevisionen in einen oder aus einem Bucket Gebühren berechnet. Weitere Informationen finden Sie unter [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/). 

1. Wechseln Sie auf dem Entwicklungscomputer in den Ordner, in dem die Dateien abgelegt sind: 

   ```
   cd c:\temp\HelloWorldApp
   ```
**Anmerkung**  
Wenn Sie nicht in diesen Ordner wechseln, startet die Dateibündelung im jeweils aktuellen Ordner. Beispiel: Wenn der aktuelle Ordner `c:\temp` statt `c:\temp\HelloWorldApp` ist, beginnt der Bündelvorgang mit den Dateien und Unterordnern im Ordner `c:\temp`, in dem u. U. mehr enthalten ist als nur der `HelloWorldApp`-Unterordner.

1. Rufen Sie den **create-application** Befehl auf, um eine neue Anwendung **HelloWorld\$1App** mit dem folgenden Namen zu registrieren CodeDeploy:

   ```
   aws deploy create-application --application-name HelloWorld_App
   ```

1. Rufen Sie den Befehl CodeDeploy [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) auf, um die Dateien zu bündeln, die Revisionen auf Amazon S3 hochzuladen und Informationen CodeDeploy über die hochgeladene Version zu registrieren — alles in einer Aktion. 

   ```
   aws deploy push --application-name HelloWorld_App --s3-location s3://amzn-s3-demo-bucket/HelloWorld_App.zip --ignore-hidden-files
   ```

   Dieser Befehl bündelt die Dateien aus dem aktuellen Verzeichnis (mit Ausnahme aller versteckten Dateien) in einer einzigen Archivdatei mit dem Namen`HelloWorld_App.zip`, lädt die Revision in den **amzn-s3-demo-bucket** Bucket hoch und registriert Informationen CodeDeploy über die hochgeladene Revision.

# Schritt 4: Stellen Sie Ihre Hello World-Anwendung bereit
<a name="tutorials-windows-deploy-application"></a>

Jetzt stellen Sie die Version der Hello World-Beispielanwendung bereit, die Sie auf Amazon S3 hochgeladen haben. Sie verwenden die AWS CLI oder die CodeDeploy Konsole, um die Version bereitzustellen und den Fortschritt der Bereitstellung zu überwachen. Im Anschluss an die Bereitstellung der Anwendungsrevision überprüfen Sie die Ergebnisse.

**Topics**
+ [Stellen Sie die Revision Ihrer Anwendung bereit mit CodeDeploy](#tutorials-windows-deploy-application-create-deployment)
+ [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](#tutorials-windows-deploy-application-monitor)
+ [Überprüfen Sie Ihre Bereitstellung](#tutorials-windows-deploy-application-verify)

## Stellen Sie die Revision Ihrer Anwendung bereit mit CodeDeploy
<a name="tutorials-windows-deploy-application-create-deployment"></a>

 Sie können Ihre Anwendung mit der CLI oder der Konsole bereitstellen. 

**Topics**
+ [Mit der CLI stellen Sie die Anwendungsrevision wie folgt bereit:](#tutorials-windows-deploy-application-create-deployment-cli)
+ [Mit der Konsole stellen Sie die Anwendungsrevision wie folgt bereit:](#tutorials-windows-deploy-application-create-deployment-console)

### Mit der CLI stellen Sie die Anwendungsrevision wie folgt bereit:
<a name="tutorials-windows-deploy-application-create-deployment-cli"></a>

1. Zuerst ist für die Bereitstellung eine Bereitstellungsgruppe erforderlich. Bevor Sie die Bereitstellungsgruppe erstellen können, benötigen Sie allerdings den ARN einer Service-Rolle. Eine Servicerolle ist eine IAM-Rolle, die einem Dienst die Erlaubnis erteilt, in Ihrem Namen zu handeln. In diesem Fall erteilt die Service-Rolle die CodeDeploy Erlaubnis, auf Ihre Amazon EC2 EC2-Instances zuzugreifen, um deren Amazon EC2 EC2-Instance-Tags zu erweitern (zu lesen).

   Sie sollten bereits anhand der Anweisungen unter [Erstellen Sie eine Servicerolle (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli) eine Service-Rolle erstellt haben. Wie Sie den ARN der Service-Rolle abrufen können, erfahren Sie unter [Rufen Sie die Servicerolle ARN (CLI) ab](getting-started-create-service-role.md#getting-started-get-service-role-cli).

1. Nachdem Sie den ARN haben, rufen Sie den **create-deployment-group** Befehl auf, um eine Bereitstellungsgruppe mit dem Namen zu erstellen**HelloWorld\$1DepGroup**, die der genannten **HelloWorld\$1App** Anwendung zugeordnet ist. Verwenden Sie dazu das Amazon EC2 EC2-Instance-Tag named **CodeDeployDemo** und die Bereitstellungskonfiguration mit dem **CodeDeployDefault.OneAtATime** Namen der Service-Rolle ARN:

   ```
   aws deploy create-deployment-group --application-name HelloWorld_App --deployment-group-name HelloWorld_DepGroup --deployment-config-name CodeDeployDefault.OneAtATime --ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE --service-role-arn serviceRoleARN
   ```
**Anmerkung**  
Der [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)Befehl bietet Unterstützung für die Erstellung von Triggern, die zum Senden von Amazon SNS SNS-Benachrichtigungen an Themenabonnenten über bestimmte Ereignisse in Bereitstellungen und Instances führen. Der Befehl unterstützt auch Optionen für das automatische Rollback von Bereitstellungen und die Einrichtung von Alarmen, um Bereitstellungen zu beenden, wenn die Überwachungsschwellenwerte in CloudWatch Amazon-Alarmen erreicht werden. Befehle für diese Aktionen sind in diesem Tutorial nicht enthalten.

1. Bevor Sie eine Bereitstellung erstellen, muss der CodeDeploy Agent auf den Instances in Ihrer Bereitstellungsgruppe installiert sein. Sie können den Agenten über die Befehlszeile mit folgendem Befehl mit AWS Systems Manager installieren:

   ```
   aws ssm create-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo --parameters action=Install,name=AWSCodeDeployAgent --schedule-expression "cron(0 2 ? * SUN *)" 
   ```

   Dieser Befehl erstellt eine Verknüpfung in Systems Manager State Manager, die den CodeDeploy Agenten installiert und dann versucht, ihn jeden Sonntagmorgen um 2:00 Uhr zu aktualisieren. Weitere Informationen zum CodeDeploy Agenten finden Sie unter [Mit dem CodeDeploy Agenten arbeiten](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html). Weitere Informationen zu Systems Manager finden Sie unter [Was ist AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).

1. Rufen Sie nun den Befehl **create-deployment** zum Erstellen einer Bereitstellung auf, die der Anwendung **HelloWorld\$1App**, der Bereitstellungskonfiguration **CodeDeployDefault.OneAtATime** und der Bereitstellungsgruppe **HelloWorld\$1DepGroup** zugeordnet ist, unter Verwendung der Anwendungrevision **HelloWorld\$1App.zip** im Bucket **amzn-s3-demo-bucket**:

   ```
   aws deploy create-deployment --application-name HelloWorld_App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name HelloWorld_DepGroup --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=HelloWorld_App.zip
   ```

### Mit der Konsole stellen Sie die Anwendungsrevision wie folgt bereit:
<a name="tutorials-windows-deploy-application-create-deployment-console"></a>

1. Bevor Sie die CodeDeploy Konsole zum Bereitstellen Ihrer Anwendungsrevision verwenden, benötigen Sie einen ARN für die Servicerolle. Eine Servicerolle ist eine IAM-Rolle, die einem Dienst die Erlaubnis erteilt, in Ihrem Namen zu handeln. In diesem Fall erteilt die Service-Rolle die CodeDeploy Erlaubnis, auf Ihre Amazon EC2 EC2-Instances zuzugreifen, um deren Amazon EC2 EC2-Instance-Tags zu erweitern (zu lesen).

   Sie sollten bereits anhand der Anweisungen unter [Erstellen Sie eine Servicerolle (Konsole)](getting-started-create-service-role.md#getting-started-create-service-role-console) eine Service-Rolle erstellt haben. Wie Sie den ARN der Service-Rolle abrufen können, erfahren Sie unter [Rufen Sie die Servicerolle ARN ab (Konsole)](getting-started-create-service-role.md#getting-started-get-service-role-console).

1. Jetzt, wo Sie den ARN haben, können Sie die CodeDeploy Konsole verwenden, um Ihre Anwendungsrevision bereitzustellen.

   Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

1. Wählen Sie **HelloWorld\$1App**.

1. Wählen Sie auf der Registerkarte **Deployment groups (Bereitstellungsgruppen)**, die Option **Create deployment group (Bereitstellungsgruppe erstellen)** aus.

1. Geben Sie unter **Deployment group name (Name der Bereitstellungsgruppe)** **HelloWorld\$1DepGroup** ein.

1. Wählen Sie unter **Service Role (Servicerolle)** den Namen der Servicerolle aus.

1. Wählen Sie unter **Deployment type (Bereitstellungstyp)** die Option **In-place (Lokal)** aus.

1. Wählen Sie unter **Umgebungskonfiguration** **Amazon EC2 EC2-Instances** aus.

1. Behalten Sie **unter Agentenkonfiguration mit AWS Systems Manager** die Standardeinstellungen bei.

1. Geben Sie für **Key (Schlüssel)** **Name** ein.

1. Geben Sie unter **Value (Wert)** **CodeDeployDemo** ein.

1. **Wählen Sie unter **Bereitstellungskonfiguration** die OptionCodeDeployDefault. OneAtATime**.

1. Deaktivieren Sie unter **Load Balancer** die Option **Enable load balancing (Load Balancing aktivieren)**.

1. Wählen Si **Create deployment group (Bereitstellungsgruppe erstellen)**.

1. Wählen Sie **Create deployment**.

1. Wählen Sie in **der Bereitstellungsgruppe** die Option **HelloWorld\$1 DepGroup**

1. Wählen Sie **unter Revisionstyp** die Option **Meine Anwendung ist in Amazon S3 gespeichert** und geben Sie dann unter **Revisionsort den Speicherort** der Version der Hello World-Beispielanwendung ein, die Sie zuvor auf Amazon S3 hochgeladen haben. Ermitteln Sie den Speicherort wie folgt:

   1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

   1. Wählen Sie in der Liste der Buckets **amzn-s3-demo-bucket** aus (oder den Namen des Buckets, in den Sie Ihre Anwendungsrevision hochgeladen haben). 

   1. **Wählen Sie in der Objektliste \$1App.zip aus. HelloWorld**

   1. Klicken Sie auf der Registerkarte **Overview (Übersicht)** auf **Copy Path (Pfad kopieren)**.

   1. Kehren Sie zur CodeDeploy Konsole zurück, und fügen Sie in **Revision Location** den Feldwert **Link** ein.

1. Wählen Sie für **Revision file type (Revisionsdateityp)** die Option **.zip** aus. 

1. (Optional) Geben Sie unter **Deployment description (Bereitstellungsbeschreibung)** einen Kommentar ein.

1. Wählen Sie **Create deployment**. Auf der Seite **Deployments** werden nun Informationen zu der neu erstellten Bereitstellung angezeigt.

## Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler
<a name="tutorials-windows-deploy-application-monitor"></a>

Verwenden Sie die Konsole AWS CLI oder die Konsole, um Ihre Bereitstellung zu überwachen und Fehler zu beheben.

**Topics**
+ [Über die CLI können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:](#tutorials-windows-deploy-application-monitor-cli)
+ [Über die Konsole können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:](#tutorials-windows-deploy-application-monitor-console)

### Über die CLI können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:
<a name="tutorials-windows-deploy-application-monitor-cli"></a>

1. Fordern Sie die ID der Bereitstellung an, indem Sie den Befehl **list-deployments** für die Anwendung **HelloWorld\$1App** und die Bereitstellungsgruppe **HelloWorld\$1DepGroup** aufrufen:

   ```
   aws deploy list-deployments --application-name HelloWorld_App --deployment-group-name HelloWorld_DepGroup --query "deployments" --output text
   ```

1. Rufen Sie den Befehl **get-deployment** mit der Bereitstellungs-ID auf:

   ```
   aws deploy get-deployment --deployment-id deploymentID --query "deploymentInfo.status" --output text
   ```

1. Der Befehl gibt den allgemeinen Status der Bereitstellung zurück. Wurde die Bereitstellung erfolgreich abgeschlossen, lautet der Wert `Succeeded`.

   Wird als allgemeiner Status `Failed` zurückgegeben, können Sie zur Problembehebung Befehle wie [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) und [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) aufrufen. Weitere Optionen für die Problembehebung finden Sie unter [Analysieren von Protokolldateien zur Untersuchung von Bereitstellungsfehlern auf Instances](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).

### Über die Konsole können Sie die Bereitstellung wie folgt überwachen und Probleme beheben:
<a name="tutorials-windows-deploy-application-monitor-console"></a>

Auf der Seite **Bereitstellungen** in der CodeDeploy Konsole können Sie den Status Ihrer Bereitstellung in der Spalte **Status** überwachen.

Weitere Informationen zu Ihrer Bereitstellung können Sie wie nachfolgend beschrieben abrufen. Dies ist insbesondere nützlich, falls in der Spalte **Status** ein anderer Wert als **Succeeded** steht:

1. Wählen Sie in der Tabelle **Deployments (Bereitstellungen)** die ID Ihrer Bereitstellung aus. Falls eine Bereitstellung fehlschlägt, wird auf der Detailseite der Bereitstellung eine Meldung mit dem Grund des Fehlschlagens angezeigt.

1. . Weitere Informationen zu den Instanzen der Bereitstellung werden angezeigt. Wenn eine Bereitstellung fehlschlägt, können Sie möglicherweise feststellen, auf welchen Amazon EC2 EC2-Instances und in welchem Schritt die Bereitstellung fehlgeschlagen ist.

1. Wenn Sie weitere Fehler beheben möchten, können Sie eine Technik wie [Instanzdetails anzeigen mit CodeDeploy](instances-view-details.md) verwenden. Sie können auch die Bereitstellungsprotokolldateien auf einer Amazon EC2 EC2-Instance analysieren. Weitere Informationen finden Sie unter [Analysieren von Protokolldateien zur Untersuchung von Bereitstellungsfehlern auf Instances](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).

## Überprüfen Sie Ihre Bereitstellung
<a name="tutorials-windows-deploy-application-verify"></a>

Überprüfen Sie nach der erfolgreichen Bereitstellung, ob die Installation funktioniert. Verwenden Sie die öffentliche DNS-Adresse der Amazon EC2 EC2-Instance, um die Webseite in einem Webbrowser anzuzeigen. (Um den öffentlichen DNS-Wert abzurufen, wählen Sie in der Amazon EC2 EC2-Konsole die Amazon EC2 EC2-Instance aus und suchen Sie auf der Registerkarte **Beschreibung** nach dem Wert in **Public DNS**.)

Wenn die öffentliche DNS-Adresse Ihrer Amazon EC2 EC2-Instance beispielsweise lautet**ec2-01-234-567-890.compute-1.amazonaws.com**, würden Sie die folgende URL verwenden:

```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```

Wenn der Vorgang erfolgreich war, sollten Sie die Webseite „Hello World\$1“ sehen.

# Schritt 5: Aktualisieren Sie Ihr „Hallo, Welt\$1“ und stellen Sie es erneut bereit Anwendung
<a name="tutorials-windows-update-and-redeploy-application"></a>

Nachdem Sie Ihre Anwendungsrevision erfolgreich bereitgestellt haben, aktualisieren Sie den Code der Webseite auf dem Entwicklungscomputer und verwenden Sie ihn dann, CodeDeploy um die Website erneut bereitzustellen. Nach der erneuten Bereitstellung sollten Sie die Änderungen an der Amazon EC2 EC2-Instance sehen können.

**Topics**
+ [Ändern Sie die Webseite](#tutorials-windows-update-and-redeploy-application-modify-code)
+ [Stellen Sie die Site erneut bereit](#tutorials-windows-update-and-redeploy-application-deploy-updates)

## Ändern Sie die Webseite
<a name="tutorials-windows-update-and-redeploy-application-modify-code"></a>

1. Gehen Sie zu Ihrem Unterordner `c:\temp\HelloWorldApp`, und modifizieren Sie die Datei `index.html` mit einem Texteditor:

   ```
   cd c:\temp\HelloWorldApp
   notepad index.html
   ```

1. Ändern Sie den Inhalt der `index.html`-Datei auf die gewünschte Hintergrundfarbe und ändern Sie Text auf der Webseite. Speichern Sie dann die Datei:

   ```
   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
   <html>
   <head>
     <title>Hello Again, World!</title>
     <style>
       body {
         color: #ffffff;
         background-color: #66cc00;
         font-family: Arial, sans-serif;  
         font-size:14px;
       }
     </style>
   </head>
   <body>
     <div align="center"><h1>Hello Again, World!</h1></div>
     <div align="center"><h2>You have successfully deployed a revision of an application using CodeDeploy</h2></div>
     <div align="center">
       <p>What to do next? Take a look through the <a href="https://aws.amazon.com/codedeploy">CodeDeploy Documentation</a>.</p>
     </div>
   </body>
   </html>
   ```

## Stellen Sie die Site erneut bereit
<a name="tutorials-windows-update-and-redeploy-application-deploy-updates"></a>

Nachdem Sie den Code geändert haben, verwenden Sie Amazon S3 und CodeDeploy stellen Sie die Webseite erneut bereit.

Bündeln Sie die Änderungen und laden Sie sie auf Amazon S3 hoch, wie unter beschrieben[Bündeln Sie die Dateien der Anwendung in einer einzigen Archivdatei und übertragen Sie die Archivdatei per Push](tutorials-windows-upload-application.md#tutorials-windows-upload-application-bundle-and-push-archive). (Wenn Sie diese Anweisungen befolgen, müssen Sie keine neue Anwendung erstellen.) Geben Sie der Revision denselben Schlüssel wie zuvor (**HelloWorld\$1App.zip**). Laden Sie es in denselben Amazon S3 S3-Bucket hoch, den Sie zuvor erstellt haben (z. B.**amzn-s3-demo-bucket**).

Verwenden Sie die AWS CLI oder die CodeDeploy Konsole, um die Site erneut bereitzustellen.

**Topics**
+ [Erneutes Bereitstellen der Website (CLI)](#tutorials-windows-update-and-redeploy-application-deploy-updates-cli)
+ [Erneutes Bereitstellen der Website (Konsole)](#tutorials-windows-update-and-redeploy-application-deploy-updates-console)

### Erneutes Bereitstellen der Website (CLI)
<a name="tutorials-windows-update-and-redeploy-application-deploy-updates-cli"></a>

Rufen Sie den Befehl **create-deployment** zum Erstellen einer Bereitstellung basierend auf der hochgeladenen Revision erneut auf. Verwenden Sie dazu erneut die Anwendung **HelloWorld\$1App**, die Bereitstellungskonfiguration **CodeDeployDefault.OneAtATime**, die Bereitstellungsgruppe **HelloWorld\$1DepGroup** und die Revision **HelloWorld\$1App.zip** im Bucket **amzn-s3-demo-bucket**:

```
 aws deploy create-deployment --application-name HelloWorld_App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name HelloWorld_DepGroup --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=HelloWorld_App.zip
```

Sie können den Status der neuen Bereitstellung überprüfen, wie in [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](tutorials-windows-deploy-application.md#tutorials-windows-deploy-application-monitor) beschrieben.

Wenn die Site erneut bereitgestellt CodeDeploy wurde, rufen Sie die Site erneut in Ihrem Webbrowser auf, um zu überprüfen, ob die Hintergrundfarbe und der Text auf der Webseite geändert wurden. (Sie müssen möglicherweise Ihren Browser aktualisieren.) Wenn die Hintergrundfarbe und der Text geändert wurden – herzlichen Glückwunsch\$1 Sie haben Ihre Website geändert und erneut bereitgestellt.

### Erneutes Bereitstellen der Website (Konsole)
<a name="tutorials-windows-update-and-redeploy-application-deploy-updates-console"></a>

1. [Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter https://console.aws.amazon.com /codedeploy.](https://console.aws.amazon.com/codedeploy)
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Wählen Sie im Navigationsbereich **Applications (Anwendungen)** aus.

1. Wählen Sie in der **Anwendungsliste** die Option **HelloWorld\$1App** aus.

1. Klicken Sie auf der Registerkarte **Deployments (Bereitstellungen)** auf **Create deployment (Bereitstellung erstellen)**.

   1. Wählen Sie in der Liste der **Bereitstellungsgruppen** die Option **HelloWorld\$1 DepGroup** aus.

   1.  Geben Sie unter **Revisionsort** den Amazon S3 S3-Link für Ihre Revision ein.

      Ermitteln des Link-Wertes:

      1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

         Navigieren Sie zu **amzn-s3-demo-bucket**, öffnen Sie es und wählen Sie dann in der Amazon S3 S3-Konsole Ihre Version aus. **HelloWorld\$1App.zip**

      1. Wenn der **Eigenschaftenbereich** in der Amazon S3 S3-Konsole nicht sichtbar ist, wählen Sie die Schaltfläche **Eigenschaften**.

      1. Kopieren Sie im Bereich **Properties (Eigenschaften)** den Wert des Felds **Link**.

      1. Kehren Sie zur CodeDeploy Konsole zurück und fügen Sie den Link in den **Ordner Revision** ein.

   1. Wenn unter **Revision file type (Revisionsdateityp)** eine Meldung darauf hinweist, dass der Dateityp nicht erkannt werden konnte, klicken Sie auf **.zip**.

   1. Lassen Sie das Feld **Deployment description (Bereitstellungsbeschreibung)** leer.

   1. **Erweitern Sie **Überschreibungen für Bereitstellungsgruppen**. Wählen Sie CodeDeployDefault in der Liste der **Bereitstellungskonfiguration** die Option aus. OneAtATime**, und wählen Sie dann **Bereitstellung erstellen** aus. 

      Sie können den Status der Bereitstellung überprüfen, wie in [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](tutorials-windows-deploy-application.md#tutorials-windows-deploy-application-monitor) beschrieben.

      Wenn die Site erneut bereitgestellt CodeDeploy wurde, rufen Sie die Site erneut in Ihrem Webbrowser auf, um zu überprüfen, ob die Hintergrundfarbe und der Text auf der Webseite geändert wurden. (Sie müssen möglicherweise Ihren Browser aktualisieren.) Wenn die Hintergrundfarbe und der Text geändert wurden – herzlichen Glückwunsch\$1 Sie haben Ihre Website geändert und erneut bereitgestellt.

# Schritt 6: Räumen Sie Ihr „Hallo, Welt\$1“ auf Anwendung und zugehörige Ressourcen
<a name="tutorials-windows-clean-up"></a>

Sie haben jetzt erfolgreich ein Update für „Hello, World\$1“ vorgenommen die Site kodiert und erneut bereitgestellt. Um laufende Gebühren für die Ressourcen, die Sie zum Abschließen dieses Tutorial erstellt haben, zu vermeiden, sollten Sie Folgendes löschen:
+ Alle CloudFormation Stacks (oder beenden Sie alle Amazon EC2 EC2-Instances, falls Sie sie außerhalb von CloudFormation erstellt haben).
+ Alle Amazon S3 S3-Buckets.
+ Die Anwendung `HelloWorld_App` in CodeDeploy.
+ Die AWS Systems Manager State Manager-Zuordnung für den CodeDeploy Agenten.

Sie können Amazon S3 AWS CLI CloudFormation, Amazon EC2 und die CodeDeploy Konsolen oder die verwenden, AWS APIs um die Bereinigung durchzuführen.

**Topics**
+ [So bereinigen Sie Ressourcen (CLI)](#tutorials-windows-clean-up-cli)
+ [So bereinigen Sie Ressourcen (Konsole):](#tutorials-windows-clean-up-console)
+ [Als nächstes](#tutorials-windows-clean-up-whats-next)

## So bereinigen Sie Ressourcen (CLI)
<a name="tutorials-windows-clean-up-cli"></a>

1. Wenn Sie den CloudFormation Stack für dieses Tutorial verwendet haben, löschen Sie den Stack, indem Sie den **delete-stack** Befehl für den genannten Stack aufrufen. **CodeDeployDemoStack** Dadurch werden alle zugehörigen Amazon EC2 EC2-Instances beendet und alle zugehörigen IAM-Rollen gelöscht, die ursprünglich vom Stack erstellt wurden.

   ```
   aws cloudformation delete-stack --stack-name CodeDeployDemoStack
   ```

1. Um den Amazon S3 S3-Bucket zu löschen, rufen Sie den **rm** Befehl mit dem **--recursive** Schalter für den genannten Bucket auf**amzn-s3-demo-bucket**. Damit werden der Bucket und alle Objekte im Bucket gelöscht.

   ```
   aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
   ```

1. Rufen Sie den **delete-application** Befehl auf CodeDeploy, um die `HelloWorld_App` Anwendung von zu löschen. Dadurch werden alle zugehörigen Bereitstellungsgruppen-Datensätze und die Bereitstellungsdatensätze für die Anwendung gelöscht.

   ```
   aws deploy delete-application --application-name HelloWorld_App
   ```

1. Rufen Sie den **delete-association** Befehl auf, um die Systems Manager State Manager-Zuordnung zu löschen.

   ```
   aws ssm delete-association --assocation-id association-id
   ```

   Sie können den abrufen, *association-id* indem Sie den **describe-association** Befehl aufrufen.

   ```
   aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
   ```

1. Wenn Sie den CloudFormation Stack für dieses Tutorial nicht verwendet haben, rufen Sie den **terminate-instances** Befehl zum Beenden von Amazon EC2 EC2-Instances auf, die Sie manuell erstellt haben. Geben Sie die ID der Amazon EC2 EC2-Instance an, die beendet werden soll.

   ```
   aws ec2 terminate-instances --instance-ids instanceId
   ```

## So bereinigen Sie Ressourcen (Konsole):
<a name="tutorials-windows-clean-up-console"></a>

Wenn Sie unsere CloudFormation Vorlage für dieses Tutorial verwendet haben, löschen Sie den zugehörigen CloudFormation Stack.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Geben Sie in das Suchfeld den CloudFormation Stack-Namen ein (z. B.**CodeDeployDemoStack**).

1. Aktivieren Sie das Kontrollkästchen neben dem Stack-Namen.

1. Wählen Sie im Menü **Actions** die Option **Delete Stack**. Dadurch wird der Stack gelöscht, alle zugehörigen Amazon EC2 EC2-Instances beendet und alle zugehörigen IAM-Rollen gelöscht.

So beenden Sie Amazon EC2 EC2-Instances, die Sie außerhalb eines CloudFormation Stacks erstellt haben:

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie im Bereich **Instances** die Option **Instances**.

1. Geben Sie in das Suchfeld den Namen der Amazon EC2 EC2-Instance ein, die Sie beenden möchten, und drücken Sie dann die **EINGABETASTE**.

1. Wählen Sie die Amazon EC2 EC2-Instance aus.

1. Wählen Sie **Actions**, zeigen Sie auf **Instance State**, und wählen Sie dann **Terminate**. Wählen Sie bei Aufforderung **Yes, Terminate**. Wiederholen Sie diese Schritte für alle weiteren Amazon EC2 EC2-Instances.

Um den Amazon S3 S3-Bucket zu löschen:

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Suchen Sie in der Liste der Buckets nach dem Namen des Amazon S3 S3-Buckets und wählen Sie ihn aus (z. B.**amzn-s3-demo-bucket**).

1. Bevor Sie einen Bucket löschen können, müssen Sie zunächst seinen Inhalt löschen. Wählen Sie alle Dateien im Bucket aus, z. B. **HelloWorld\$1App.zip**. Wählen Sie im Menü **Actions** die Option **Delete**. Wenn Sie zum Bestätigen des Löschvorgangs aufgefordert werden, wählen Sie **OK**. 

1. Nachdem der Bucket leer ist, kann er gelöscht werden. Wählen Sie in der Bucket-Liste die Zeile mit dem Bucket aus (aber nicht den Namen des Buckets). Wählen Sie **Delete bucket** und bei der Aufforderung zum Bestätigen **OK**. 

Um die `HelloWorld_App` Anwendung zu löschen von CodeDeploy:

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

   

1. Wählen Sie **`HelloWorld_App`**.

1. Klicken Sie auf **Delete Application (Anwendung löschen)**.

1. Geben Sie bei der Aufforderung **Delete** ein und klicken Sie dann auf **Delete (Löschen)**. 

So löschen Sie die Systems Manager State Manager-Zuordnung:

1. Öffnen Sie die AWS Systems Manager Konsole unter https://console.aws.amazon.com /systems-manager.

1. Wählen Sie im Navigationsbereich **Statusmanager** aus.

1. Wählen Sie die Verknüpfung aus, die Sie erstellt haben, und wählen Sie **Delete (Löschen)** aus.

## Als nächstes
<a name="tutorials-windows-clean-up-whats-next"></a>

Wenn Sie hier angekommen sind, haben Sie eine Bereitstellung mit erfolgreich abgeschlossen. CodeDeploy Herzlichen Glückwunsch\$1

# Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)
<a name="tutorials-on-premises-instance"></a>

Dieses Tutorial hilft Ihnen dabei, Erfahrungen zu sammeln, CodeDeploy indem es Sie durch die Bereitstellung einer Beispielanwendungsrevision auf einer einzelnen lokalen Instanz — d. h. einem physischen Gerät, das keine Amazon EC2 EC2-Instance ist — führt, auf der Windows Server, Ubuntu Server oder Red Hat Enterprise Linux (RHEL) ausgeführt wird. Informationen zu lokalen Instances und deren Verwendung finden Sie unter. CodeDeploy [Arbeiten mit lokalen Instanzen für CodeDeploy](instances-on-premises.md)

Nicht das, wonach Sie gesucht haben?
+ Informationen zum Bereitstellen auf einer Amazon EC2 EC2-Instance, auf der Amazon Linux oder RHEL ausgeführt wird, finden Sie unter. [Tutorial: Bereitstellung WordPress auf einer Amazon EC2 EC2-Instance (Amazon Linux oder Red Hat Enterprise Linux und Linux, macOS oder Unix)](tutorials-wordpress.md)
+ Informationen zum Bereitstellen auf einer Amazon EC2 EC2-Instance, auf der Windows Server ausgeführt wird, finden Sie unter[Tutorial: Bereite ein „Hallo, Welt\$1“ vor Anwendung mit CodeDeploy (Windows Server)](tutorials-windows.md).

**Topics**
+ [Voraussetzungen](tutorials-on-premises-instance-prerequisites.md)
+ [Schritt 1: Konfigurieren Sie die lokale Instanz](tutorials-on-premises-instance-1-configure-instance.md)
+ [Schritt 2: Erstellen Sie eine Version der Beispielanwendung](tutorials-on-premises-instance-2-create-sample-revision.md)
+ [Schritt 3: Bündeln Sie Ihre Anwendungsrevision und laden Sie sie auf Amazon S3 hoch](tutorials-on-premises-instance-3-bundle-sample-revision.md)
+ [Schritt 4: Stellen Sie die Revision Ihrer Anwendung bereit](tutorials-on-premises-instance-4-deploy-sample-revision.md)
+ [Schritt 5: Überprüfen Sie Ihre Bereitstellung](tutorials-on-premises-instance-5-verify-deployment.md)
+ [Schritt 6: Bereinigen von Ressourcen](tutorials-on-premises-instance-6-clean-up-resources.md)

# Voraussetzungen
<a name="tutorials-on-premises-instance-prerequisites"></a>

Bevor Sie mit diesem Tutorial beginnen, müssen Sie die Voraussetzungen unter erfüllen. Dazu gehören die Konfiguration eines Benutzers, die Installation oder Aktualisierung von und die AWS CLI Erstellung einer Servicerolle. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md) Sie müssen kein IAM-Instanzprofil erstellen, wie in den Voraussetzungen beschrieben. Lokale Instanzen verwenden keine IAM-Instanzprofile.

Das physische Gerät, das Sie als lokale Instance konfigurieren, muss eines der Betriebssysteme ausführen, die aufgeführt sind in [Betriebssysteme, die vom Agenten unterstützt werden CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).

# Schritt 1: Konfigurieren Sie die lokale Instanz
<a name="tutorials-on-premises-instance-1-configure-instance"></a>

Bevor Sie etwas auf einer lokalen Instance bereitstellen können, müssen Sie diese konfigurieren. Befolgen Sie die Anweisungen unter [Arbeiten mit lokalen Instanzen für CodeDeploy](instances-on-premises.md), und kehren Sie dann zu dieser Seite zurück.

## Installieren Sie den Agenten CodeDeploy
<a name="tutorials-on-premises-instance-1-configure-instance-agent"></a>

Nachdem Sie Ihre lokale Instanz konfiguriert haben, folgen Sie den Schritten für lokale Instanzen unter [Den CodeDeploy Agenten installieren](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent-operations-install.html) und kehren Sie zu dieser Seite zurück.

# Schritt 2: Erstellen Sie eine Version der Beispielanwendung
<a name="tutorials-on-premises-instance-2-create-sample-revision"></a>

In diesem Schritt erstellen Sie eine Beispielanwendungsrevision, die auf der lokalen Instance bereitgestellt werden soll. 

Da es schwierig ist zu wissen, welche Software und Funktionen auf Ihrer lokalen Instanz bereits installiert sind — oder gemäß den Richtlinien Ihres Unternehmens installiert werden dürfen —, verwendet die hier angebotene Version der Beispielanwendung einfach Batchskripts (für Windows Server) oder Shellskripts (für Ubuntu Server und RHEL), um Textdateien an einen Speicherort auf Ihrer lokalen Instanz zu schreiben. Eine Datei wird für jedes von mehreren Ereignissen im CodeDeploy Bereitstellungslebenszyklus geschrieben, einschließlich **Install **AfterInstall****, **ApplicationStart**, und **ValidateService**. Während des **BeforeInstall**Bereitstellungslebenszyklus wird ein Skript ausgeführt, um alte Dateien zu entfernen, die während früherer Bereitstellungen dieses Beispiels geschrieben wurden, und um einen Speicherort auf Ihrer lokalen Instanz zu erstellen, in den die neuen Dateien geschrieben werden. 

**Anmerkung**  
Die Bereitstellung dieser Beispielanwendungsrevision schlägt fehl, wenn eine der folgenden Aussagen wahr ist:  
Der Benutzer, der den CodeDeploy Agenten auf der lokalen Instanz startet, ist nicht berechtigt, Skripts auszuführen.
Der Benutzer ist nicht berechtigt, Ordner an den in den Skripten aufgeführten Speicherorten zu erstellen oder zu löschen.
Der Benutzer ist nicht berechtigt, Textdateien an den in den Skripten aufgeführten Speicherorten zu erstellen.

**Anmerkung**  
Wenn Sie eine Windows Server-Instanz konfiguriert haben und ein anderes Beispiel bereitstellen möchten, sollten Sie das Beispiel aus [Schritt 2: Konfigurieren Sie Ihren Quellinhalt für die Bereitstellung auf der Windows Server Amazon EC2 EC2-Instance](tutorials-windows-configure-content.md) dem [Tutorial: Bereite ein „Hallo, Welt\$1“ vor Anwendung mit CodeDeploy (Windows Server)](tutorials-windows.md) Tutorial verwenden.  
Wenn Sie eine RHEL-Instanz konfiguriert haben und ein anderes Beispiel bereitstellen möchten, sollten Sie das Beispiel aus [Schritt 2: Konfigurieren Sie Ihren Quellinhalt für die Bereitstellung auf der Amazon Linux- oder Red Hat Enterprise Linux Amazon EC2 EC2-Instance](tutorials-wordpress-configure-content.md) dem [Tutorial: Bereitstellung WordPress auf einer Amazon EC2 EC2-Instance (Amazon Linux oder Red Hat Enterprise Linux und Linux, macOS oder Unix)](tutorials-wordpress.md) Tutorial verwenden.  
Derzeit gibt es kein alternatives Beispiel für Ubuntu Server.

1. Erstellen Sie auf dem Bereitstellungscomputer ein Unterverzeichnis (Unterordner) mit der Bezeichnung `CodeDeployDemo-OnPrem`, in dem die Dateien der Beispielanwendungsrevision gespeichert werden, und wechseln Sie zu diesem Unterordner. In diesem Beispiel gehen wir davon aus, dass Sie den `c:\temp` Ordner als Stammordner für Windows Server oder den `/tmp` Ordner als Stammordner für Ubuntu Server und RHEL verwenden. Wenn Sie einen anderen Ordner verwenden, müssen Sie im gesamten Tutorial unseren Ordnernamen durch Ihren Ordnernamen ersetzen: 

   Für Windows:

   ```
   mkdir c:\temp\CodeDeployDemo-OnPrem
   cd c:\temp\CodeDeployDemo-OnPrem
   ```

   Für Linux, macOS oder Unix:

   ```
   mkdir /tmp/CodeDeployDemo-OnPrem
   cd /tmp/CodeDeployDemo-OnPrem
   ```

1. Verwenden Sie im Stammverzeichnis des Unterordners `CodeDeployDemo-OnPrem` einen Texteditor zur Erstellung zweier Dateien mit den Bezeichnungen `appspec.yml` und `install.txt`:

   `appspec.yml`für Windows Server:

   ```
   version: 0.0
   os: windows
   files:
     - source: .\install.txt
       destination: c:\temp\CodeDeployExample
   hooks:
     BeforeInstall:
       - location: .\scripts\before-install.bat
         timeout: 900
     AfterInstall:
       - location: .\scripts\after-install.bat     
         timeout: 900
     ApplicationStart:
       - location: .\scripts\application-start.bat  
         timeout: 900
     ValidateService:
       - location: .\scripts\validate-service.bat    
         timeout: 900
   ```

   `appspec.yml`für Ubuntu Server und RHEL:

   ```
   version: 0.0
   os: linux
   files:
     - source: ./install.txt
       destination: /tmp/CodeDeployExample
   hooks:
     BeforeInstall:
       - location: ./scripts/before-install.sh
         timeout: 900
     AfterInstall:
       - location: ./scripts/after-install.sh
         timeout: 900
     ApplicationStart:
       - location: ./scripts/application-start.sh
         timeout: 900
     ValidateService:
       - location: ./scripts/validate-service.sh
         timeout: 900
   ```

   Weitere Informationen zu AppSpec Dateien finden Sie unter [Hinzufügen einer Anwendungsspezifikationsdatei zu einer Revision für CodeDeploy](application-revisions-appspec-file.md) und[CodeDeploy AppSpec Dateiverweis](reference-appspec-file.md).

   `install.txt`:

   ```
   The Install deployment lifecycle event successfully completed.
   ```

1. Erstellen Sie im Stammverzeichnis des Unterordners `CodeDeployDemo-OnPrem` einen Unterordner `scripts`, und wechseln Sie dann zu diesem Ordner:

   Für Windows:

   ```
   mkdir c:\temp\CodeDeployDemo-OnPrem\scripts
   cd c:\temp\CodeDeployDemo-OnPrem\scripts
   ```

   Für Linux, macOS oder Unix:

   ```
   mkdir -p /tmp/CodeDeployDemo-OnPrem/scripts
   cd /tmp/CodeDeployDemo-OnPrem/scripts
   ```

1. Verwenden Sie einen Texteditor, um im Stammverzeichnis des `scripts` Unterordners vier Dateien mit den Namen `before-install.bat``after-install.bat`,`application-start.bat`, und `validate-service.bat` für Windows Server oder, `before-install.sh` `after-install.sh``application-start.sh`, und `validate-service.sh` für Ubuntu Server und RHEL zu erstellen:

   Für Windows Server:

   `before-install.bat`:

   ```
   set FOLDER=%HOMEDRIVE%\temp\CodeDeployExample
   
   if exist %FOLDER% (
     rd /s /q "%FOLDER%"
   )
   
   mkdir %FOLDER%
   ```

   `after-install.bat`:

   ```
   cd %HOMEDRIVE%\temp\CodeDeployExample
   
   echo The AfterInstall deployment lifecycle event successfully completed. > after-install.txt
   ```

   `application-start.bat`:

   ```
   cd %HOMEDRIVE%\temp\CodeDeployExample
   
   echo The ApplicationStart deployment lifecycle event successfully completed. > application-start.txt
   ```

   `validate-service.bat`:

   ```
   cd %HOMEDRIVE%\temp\CodeDeployExample
   
   echo The ValidateService deployment lifecycle event successfully completed. > validate-service.txt
   ```

   Für Ubuntu Server und RHEL:

   `before-install.sh`:

   ```
   #!/bin/bash
   export FOLDER=/tmp/CodeDeployExample
   
   if [ -d $FOLDER ]
   then
    rm -rf $FOLDER
   fi
   
   mkdir -p $FOLDER
   ```

   `after-install.sh`:

   ```
   #!/bin/bash
   cd /tmp/CodeDeployExample
   
   echo "The AfterInstall deployment lifecycle event successfully completed." > after-install.txt
   ```

   `application-start.sh`:

   ```
   #!/bin/bash
   cd /tmp/CodeDeployExample
   
   echo "The ApplicationStart deployment lifecycle event successfully completed." > application-start.txt
   ```

   `validate-service.sh`:

   ```
   #!/bin/bash
   cd /tmp/CodeDeployExample
   
   echo "The ValidateService deployment lifecycle event successfully completed." > validate-service.txt
   
   unset FOLDER
   ```

1. Stellen Sie nur für Ubuntu Server und RHEL sicher, dass die vier Shell-Skripte über Ausführungsberechtigungen verfügen:

   ```
   chmod +x ./scripts/*
   ```

# Schritt 3: Bündeln Sie Ihre Anwendungsrevision und laden Sie sie auf Amazon S3 hoch
<a name="tutorials-on-premises-instance-3-bundle-sample-revision"></a>

Bevor Sie Ihre Anwendungsrevision bereitstellen können, müssen Sie die Dateien bündeln und dann das Dateipaket in einen Amazon S3 S3-Bucket hochladen. Befolgen Sie die Anweisungen unter [Erstellen Sie eine Anwendung mit CodeDeploy](applications-create.md) und [Eine Revision CodeDeploy auf Amazon S3 übertragen (nur EC2/On-Premises-Bereitstellungen)](application-revisions-push.md). (Sie können die Anwendung und die Bereitstellungsgruppe zwar beliebig benennen, empfohlen werden jedoch der Anwendungsname `CodeDeploy-OnPrem-App` und der Bereitstellungsgruppenname `CodeDeploy-OnPrem-DG`.) Nachdem Sie diese Anweisungen ausgeführt haben, kehren Sie zu dieser Seite zurück. 

**Anmerkung**  
Alternativ können Sie das Dateipaket in ein GitHub Repository hochladen und von dort aus bereitstellen. Weitere Informationen finden Sie unter [Integrieren CodeDeploy mit GitHub](integrations-partners-github.md).

# Schritt 4: Stellen Sie die Revision Ihrer Anwendung bereit
<a name="tutorials-on-premises-instance-4-deploy-sample-revision"></a>

Nachdem Sie Ihre Anwendungsversion in einen Amazon S3 S3-Bucket hochgeladen haben, versuchen Sie, sie auf Ihrer lokalen Instance bereitzustellen. Befolgen Sie die Anweisungen unter [Erstellen Sie eine Bereitstellung mit CodeDeploy](deployments-create.md), und kehren Sie dann zu dieser Seite zurück.

# Schritt 5: Überprüfen Sie Ihre Bereitstellung
<a name="tutorials-on-premises-instance-5-verify-deployment"></a>

Um zu überprüfen, ob die Bereitstellung erfolgreich war, befolgen Sie die Anweisungen unter [CodeDeploy Bereitstellungsdetails anzeigen](deployments-view-details.md), und dann kehren Sie zu dieser Seite zurück.

Wenn die Bereitstellung erfolgreich war, finden Sie vier Textdateien im `c:\temp\CodeDeployExample` Ordner (für Windows Server) oder `/tmp/CodeDeployExample` (für Ubuntu Server und RHEL). 

Schlug die Bereitstellung fehl, dann befolgen Sie Fehlerbehandlungsschritte unter [Instanzdetails anzeigen mit CodeDeploy](instances-view-details.md) und [Beheben von Instance-Problemen](troubleshooting-ec2-instances.md). Nehmen Sie die notwendigen Korrekturen vor, packen Sie die Anwendungsrevision erneut, laden Sie sie hoch, und versuchen Sie erneut, die Bereitstellung durchzuführen.

# Schritt 6: Bereinigen von Ressourcen
<a name="tutorials-on-premises-instance-6-clean-up-resources"></a>

Um laufende Gebühren für Ressourcen zu vermeiden, die Sie für dieses Tutorial erstellt haben, löschen Sie den Amazon S3 S3-Bucket, wenn Sie ihn nicht mehr verwenden werden. Sie können auch zugehörige Ressourcen bereinigen, z. B. die Anwendungs- und Bereitstellungsgruppeneinträge in CodeDeploy der lokalen Instance.

Sie können die AWS CLI oder eine Kombination aus den CodeDeploy und Amazon S3 S3-Konsolen und den verwenden AWS CLI , um Ressourcen zu bereinigen. 

## Ressourcen bereinigen (CLI)
<a name="tutorials-on-premises-instance-6-clean-up-resources-cli"></a>

**Um den Amazon S3 S3-Bucket zu löschen**
+ Rufen Sie den Befehl [rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) mit der Befehlszeilenoption `--recursive` für den Bucket auf (z. B. `amzn-s3-demo-bucket`). Der Bucket und alle im Bucket enthaltenen Objekte werden gelöscht. 

  ```
  aws s3 rm s3://your-bucket-name --recursive --region region
  ```

**Um die Anwendungs- und Bereitstellungsgruppeneinträge zu löschen in CodeDeploy**
+ Rufen Sie den Befehl [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) für die Anwendung auf (z. B.). `CodeDeploy-OnPrem-App` Die Datensätze für die Bereitstellung und die Bereitstellungsgruppe werden gelöscht. 

  ```
  aws deploy delete-application --application-name your-application-name
  ```<a name="tutorials-on-premises-instance-6-clean-up-resources-deregister-cli"></a>

**Um die Registrierung der lokalen Instanz aufzuheben und den IAM-Benutzer zu löschen**
+ Rufen Sie den Befehl [deregister](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html) für die lokale Instanz und Region auf:

  ```
  aws deploy deregister --instance-name your-instance-name --delete-iam-user --region your-region
  ```
**Anmerkung**  
Wenn Sie den mit dieser lokalen Instanz verknüpften IAM-Benutzer nicht löschen möchten, verwenden Sie stattdessen die Option. `--no-delete-iam-user`

**Um den CodeDeploy Agenten zu deinstallieren und die Konfigurationsdatei aus der lokalen Instanz zu entfernen**
+ Rufen Sie von der lokalen Instanz aus den [Deinstallationsbefehl](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html) auf:

  ```
  aws deploy uninstall
  ```

Sie haben jetzt alle Schritte ausgeführt, um die Ressourcen zu bereinigen, die in diesem Tutorial verwendet wurden.

## Ressourcen bereinigen (Konsole)
<a name="tutorials-on-premises-instance-6-clean-up-resources-console"></a>

**Um den Amazon S3 S3-Bucket zu löschen**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie das Symbol neben dem Bucket aus, den Sie löschen möchten (z. B. `amzn-s3-demo-bucket`), ohne jedoch den Bucket auszuwählen.

1. Wählen Sie **Aktionen** und anschließend **Löschen** aus. 

1. Wenn Sie zum Löschen des Buckets aufgefordert werden, wählen Sie **OK**. 

**Um die Anwendungs- und Bereitstellungsgruppeneinträge zu löschen CodeDeploy**

1. Melden Sie sich bei [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy) an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole.
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Wählen Sie im Navigationsbereich **Applications (Anwendungen)** aus.

1. Wählen Sie den Namen der Anwendung aus, die Sie löschen möchten (z. B. `CodeDeploy-OnPrem-App`) und klicken Sie auf **Delete Application (Anwendung löschen)**.

1. Geben Sie bei Aufforderung den Namen der Anwendung ein, um das Löschen zu bestätigen, und klicken Sie auf **Delete (Löschen)**. 

Sie können die AWS CodeDeploy Konsole nicht verwenden, um die lokale Instanz abzumelden oder den Agenten zu deinstallieren. CodeDeploy Folgen Sie den Anweisungen in [Um die Registrierung der lokalen Instanz aufzuheben und den IAM-Benutzer zu löschen](#tutorials-on-premises-instance-6-clean-up-resources-deregister-cli).

# Tutorial: Wird verwendet CodeDeploy , um eine Anwendung für eine Auto Scaling Scaling-Gruppe bereitzustellen
<a name="tutorials-auto-scaling-group"></a>

In diesem Tutorial verwenden Sie, CodeDeploy um eine Anwendungsrevision für eine Auto Scaling Scaling-Gruppe bereitzustellen. Amazon EC2 Auto Scaling startet Amazon EC2 EC2-Instances unter Verwendung vordefinierter Bedingungen und beendet diese Instances dann, wenn sie nicht mehr benötigt werden. Amazon EC2 Auto Scaling kann bei der Skalierung helfen CodeDeploy , indem sichergestellt wird, dass immer die richtige Anzahl von Amazon EC2 EC2-Instances zur Verfügung steht, um die Last für Bereitstellungen zu bewältigen. Informationen zur Amazon EC2 Auto Scaling Scaling-Integration mit finden Sie CodeDeploy unter[Integration CodeDeploy mit Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).

**Topics**
+ [Voraussetzungen](tutorials-auto-scaling-group-prerequisites.md)
+ [Schritt 1: Auto Scaling Scaling-Gruppe erstellen und konfigurieren](tutorials-auto-scaling-group-create-auto-scaling-group.md)
+ [Schritt 2: Bereitstellen der Anwendung in der Auto Scaling Scaling-Gruppe](tutorials-auto-scaling-group-create-deployment.md)
+ [Schritt 3: Überprüfen Sie Ihre Ergebnisse](tutorials-auto-scaling-group-verify.md)
+ [Schritt 4: Erhöhen Sie die Anzahl der Amazon EC2 EC2-Instances in der Auto Scaling Scaling-Gruppe](tutorials-auto-scaling-group-scale-up.md)
+ [Schritt 5: Überprüfen Sie Ihre Ergebnisse erneut](tutorials-auto-scaling-group-reverify.md)
+ [Schritt 6: Bereinigen](tutorials-auto-scaling-group-clean-up.md)

# Voraussetzungen
<a name="tutorials-auto-scaling-group-prerequisites"></a>

So folgen Sie diesem Tutorial:
+ Führen Sie alle Schritte unter aus[Erste Schritte mit CodeDeploy](getting-started-codedeploy.md), einschließlich der Einrichtung und Konfiguration des AWS CLI IAM-Instanzprofils (**CodeDeployDemo-EC2-Instance-Profile**) und einer Servicerolle (**CodeDeployDemo**). Eine *Servicerolle* ist eine besondere Art von IAM-Rolle, die einem Dienst die Erlaubnis erteilt, in Ihrem Namen zu handeln.
+ Wenn Sie Ihre Auto Scaling Scaling-Gruppe mit einer Startvorlage erstellen, müssen Sie die folgenden Berechtigungen hinzufügen:
  +  `ec2:RunInstances` 
  +  `ec2:CreateTags` 
  +  `iam:PassRole` 

  Weitere Informationen finden Sie unter [Schritt 2: Erstellen Sie eine Servicerolle](getting-started-create-service-role.md) [Erstellen einer Startvorlage für eine Auto Scaling Scaling-Gruppe](https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html) und [Unterstützung von Startvorlagen](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-launch-template-permissions.html) im *Amazon EC2 Auto Scaling Scaling-Benutzerhandbuch*. 
+  Erstellen und verwenden Sie eine Version, die mit einer Ubuntu-Server-Instance kompatibel ist und CodeDeploy. Für Ihre Revision können Sie einen der folgenden Schritte ausführen:
  + Erstellen und verwenden Sie die Beispielrevision in [Schritt 2: Erstellen Sie eine Version der Beispielanwendung](tutorials-on-premises-instance-2-create-sample-revision.md) im Tutorial [Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)](tutorials-on-premises-instance.md). 
  + Informationen zum Erstellen einer eigenen Revision finden Sie unter [Arbeiten mit Anwendungsrevisionen für CodeDeploy](application-revisions.md).
+ Erstellen Sie eine Sicherheitsgruppe **CodeDeployDemo-AS-SG** mit dem Namen der folgenden **Regel für eingehende Nachrichten**:
  + Typ: HTTP
  + Quelle: Irgendwo

  Dies ist erforderlich, um Ihre Anwendung anzuzeigen und den Erfolg der Bereitstellung zu überprüfen. Informationen zum Erstellen einer Sicherheitsgruppe finden Sie unter [Erstellen einer Sicherheitsgruppe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) im *Amazon EC2 EC2-Benutzerhandbuch*.

 

# Schritt 1: Auto Scaling Scaling-Gruppe erstellen und konfigurieren
<a name="tutorials-auto-scaling-group-create-auto-scaling-group"></a>

In diesem Schritt erstellen Sie eine Auto Scaling Scaling-Gruppe, die eine einzelne Amazon Linux-, RHEL- oder Windows Server Amazon EC2 EC2-Instance enthält. In einem späteren Schritt werden Sie Amazon EC2 Auto Scaling anweisen, eine weitere Amazon EC2-Instance hinzuzufügen, und CodeDeploy Ihre Revision darauf bereitstellen.

**Topics**
+ [So erstellen und konfigurieren Sie die Auto Scaling Scaling-Gruppe (CLI)](#tutorials-auto-scaling-group-create-auto-scaling-group-cli)
+ [So erstellen und konfigurieren Sie die Auto Scaling Scaling-Gruppe (Konsole)](#tutorials-auto-scaling-group-create-auto-scaling-group-console)

## So erstellen und konfigurieren Sie die Auto Scaling Scaling-Gruppe (CLI)
<a name="tutorials-auto-scaling-group-create-auto-scaling-group-cli"></a>

1. Rufen Sie den **create-launch-template** Befehl auf, um eine Amazon EC2 EC2-Startvorlage zu erstellen.

   Bevor Sie diesen Befehl aufrufen, benötigen Sie die ID eines AMIs, das für dieses Tutorial funktioniert, dargestellt durch den Platzhalter*image-id*. Sie benötigen außerdem den Namen eines Amazon EC2 EC2-Instance-Schlüsselpaars, um den Zugriff auf die Amazon EC2 EC2-Instance zu ermöglichen, dargestellt durch den Platzhalter. *key-name*

   So rufen Sie die ID eines AMI ab, das mit diesem Tutorial funktioniert:

   1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

   1. Wählen Sie im Navigationsbereich unter **Instances** **Instances** und dann **Launch Instance**.

   1. Notieren Sie sich auf der Registerkarte **Schnellstart** der Seite „**Amazon Machine Image auswählen**“ die ID des AMI neben **Amazon Linux 2 AMI**, **Red Hat Enterprise Linux 7.1**, **Ubuntu Server 14.04 LTS** oder **Microsoft Windows Server** 2012 R2. 
**Anmerkung**  
Wenn Sie über eine benutzerdefinierte Version eines AMI verfügen, das mit CodeDeploy kompatibel ist, wählen Sie es hier aus, statt über die Registerkarte **Quick Start (Schnellstart)** zu navigieren. Informationen zur Verwendung eines benutzerdefinierten AMI mit CodeDeploy Amazon EC2 Auto Scaling finden Sie unter[Verwenden eines benutzerdefinierten AMI mit CodeDeploy Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md#integrations-aws-auto-scaling-custom-ami).

   Verwenden Sie für das Amazon EC2 EC2-Instance-Schlüsselpaar den Namen Ihres Amazon EC2 EC2-Instance-Schlüsselpaars.

   Führen Sie den Befehl **create-launch-template** aus.

   Auf lokalen Linux-, macOS- oder Unix-Computern:

   ```
   aws ec2 create-launch-template \
     --launch-template-name CodeDeployDemo-AS-Launch-Template \
     --launch-template-data file://config.json
   ```

   Der Inhalt der `config.json` Datei:

   ```
   { 
     "InstanceType":"t1.micro",
     "ImageId":"image-id",
     "IamInstanceProfile":{
       "Name":"CodeDeployDemo-EC2-Instance-Profile"
     },
     "KeyName":"key-name"
   }
   ```

   Auf lokalen Computern mit Windows:

   ```
   aws ec2 create-launch-template --launch-template-name CodeDeployDemo-AS-Launch-Template --launch-template-data file://config.json
   ```

   Der Inhalt der `config.json` Datei:

   ```
   { 
     "InstanceType":"t1.micro",
     "ImageId":"image-id",
     "IamInstanceProfile":{
       "Name":"CodeDeployDemo-EC2-Instance-Profile"
     },
     "KeyName":"key-name"
   }
   ```

   Diese Befehle erstellen zusammen mit der `config.json` Datei eine Amazon EC2 EC2-Startvorlage mit dem Namen CodeDeployDemo-AS-Launch-Template Ihrer Auto Scaling Scaling-Gruppe, die in einem nächsten Schritt auf der Grundlage des Amazon EC2 EC2-Instance-Typs t1.micro erstellt wird. Basierend auf Ihrer Eingabe für `ImageId``IamInstanceProfile`, und spezifiziert die Startvorlage auch die AMI-ID`KeyName`, den Namen des Instance-Profils, das mit der IAM-Rolle verknüpft ist, das beim Start an Instances übergeben werden soll, und das Amazon EC2 EC2-Schlüsselpaar, das beim Herstellen einer Verbindung zu Instances verwendet werden soll.

1.  Rufen Sie den **create-auto-scaling-group** Befehl auf, um eine Auto Scaling Scaling-Gruppe zu erstellen. Sie benötigen den Namen einer der Availability Zones in einer der unter [Region aufgeführten Regionen und den Namen der Endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in der *Allgemeine AWS-Referenz*, dargestellt durch den Platzhalter*availability-zone*.
**Anmerkung**  
So zeigen Sie eine Liste der Availability Zones in einer Region an:   

   ```
   aws ec2 describe-availability-zones --region region-name
   ```
Um beispielsweise eine Liste der Availability Zones in der Region USA West (Oregon) einzusehen, rufen Sie an:  

   ```
   aws ec2 describe-availability-zones --region us-west-2
   ```
Eine Liste der Regionen-Namensbezeichner finden Sie unter [Bucket-Namen für das Resource Kit nach Regionen](resource-kit.md#resource-kit-bucket-names).

   Auf lokalen Linux-, macOS- oder Unix-Computern:

   ```
   aws autoscaling create-auto-scaling-group \
     --auto-scaling-group-name CodeDeployDemo-AS-Group \
     --launch-template CodeDeployDemo-AS-Launch-Template,Version='$Latest' \
     --min-size 1 \
     --max-size 1 \
     --desired-capacity 1 \
     --availability-zones availability-zone \
     --tags Key=Name,Value=CodeDeployDemo,PropagateAtLaunch=true
   ```

   Auf lokalen Computern mit Windows:

   ```
   aws autoscaling create-auto-scaling-group --auto-scaling-group-name CodeDeployDemo-AS-Group --launch-template LaunchTemplateName=CodeDeployDemo-AS-Launch-Template,Version="$Latest" --min-size 1 --max-size 1 --desired-capacity 1 --availability-zones availability-zone --tags Key=Name,Value=CodeDeployDemo,PropagateAtLaunch=true
   ```

   Mit diesen Befehlen wird eine Auto Scaling Scaling-Gruppe erstellt, die auf der benannten Amazon EC2 EC2-Startvorlage **CodeDeployDemo-AS-Group** basiert. **CodeDeployDemo-AS-Launch-Template** Diese Auto Scaling Scaling-Gruppe hat nur eine Amazon EC2 EC2-Instance und sie wird in der angegebenen Availability Zone erstellt. Jede Instanz in dieser Auto Scaling Scaling-Gruppe wird das Tag haben`Name=CodeDeployDemo`. Das Tag wird bei der späteren Installation des CodeDeploy Agenten verwendet.

1. Rufen Sie den Befehl **describe-auto-scaling-groups** für **CodeDeployDemo-AS-Group** auf:

   ```
   aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].[HealthStatus, LifecycleState]" --output text
   ```

   Fahren Sie erst fort, wenn die zurückgegebenen Werte `Healthy` und `InService` anzeigen.

1.  Auf den Instances in Ihrer Auto Scaling Scaling-Gruppe muss der CodeDeploy Agent installiert sein, damit er in CodeDeploy Bereitstellungen verwendet werden kann. Installieren Sie den CodeDeploy Agenten, indem Sie den **create-association** Befehl AWS Systems Manager mit den Tags aufrufen, die bei der Erstellung der Auto Scaling Scaling-Gruppe hinzugefügt wurden. 

   ```
   aws ssm create-association \
     --name AWS-ConfigureAWSPackage \
     --targets Key=tag:Name,Values=CodeDeployDemo \
    
 --parameters action=Install, name=AWSCodeDeployAgent \
     --schedule-expression "cron(0 2 ? * SUN *)"
   ```

   Dieser Befehl erstellt eine Verknüpfung in Systems Manager State Manager, die den CodeDeploy Agenten auf allen Instances in der Auto Scaling Scaling-Gruppe installiert und dann versucht, ihn jeden Sonntagmorgen um 2:00 Uhr zu aktualisieren. Weitere Informationen zum CodeDeploy Agenten finden Sie unter [Mit dem CodeDeploy Agenten arbeiten](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html). Weitere Informationen zu Systems Manager finden Sie unter [Was ist AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).

## So erstellen und konfigurieren Sie die Auto Scaling Scaling-Gruppe (Konsole)
<a name="tutorials-auto-scaling-group-create-auto-scaling-group-console"></a>

1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Vergewissern Sie sich, dass in der globalen Navigationsleiste eine der Regionen ausgewählt *Allgemeine AWS-Referenz*ist, die [unter Region und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in der aufgeführt sind. Amazon EC2 Auto Scaling Scaling-Ressourcen sind an die von Ihnen angegebene Region gebunden und CodeDeploy werden nur in ausgewählten Regionen unterstützt.

1. Wählen Sie in der Navigationsleiste unter **Instances** die Option **Launch Templates** aus.

1. Wählen Sie **Startvorlage erstellen**.

1. Geben **Sie im Dialogfeld Name und Beschreibung der Startvorlage** als **Namen der Startvorlage** Folgendes ein**CodeDeployDemo-AS-Launch-Template**. Behalten Sie die Standardwerte für die anderen Felder bei.

1. Klicken Sie im Dialogfeld **Amazon Machine Image (AMI)** auf das Drop-down-Menü unter **AMI** und wählen Sie ein AMI aus, das mit diesem Tutorial funktioniert:

   1. Wählen Sie auf der Registerkarte **Schnellstart** der **AMI-Dropdown-Liste** eine der folgenden Optionen aus: **Amazon Linux 2 AMI**, **Red Hat Enterprise Linux 7.1**, **Ubuntu Server 14.04 LTS** oder **Microsoft Windows** Server 2012 R2. 
**Anmerkung**  
Wenn Sie über eine benutzerdefinierte Version eines AMI verfügen, das mit CodeDeploy kompatibel ist, wählen Sie es hier aus, statt über die Registerkarte **Quick Start (Schnellstart)** zu navigieren. Informationen zur Verwendung eines benutzerdefinierten AMI mit CodeDeploy Amazon EC2 Auto Scaling finden Sie unter[Verwenden eines benutzerdefinierten AMI mit CodeDeploy Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md#integrations-aws-auto-scaling-custom-ami).

1. **Wählen Sie unter **Instanztyp** die Dropdownliste aus und wählen Sie t1.micro aus.** Sie können die Suchleiste verwenden, um es schneller zu finden.

1. Wählen Sie im Dialogfeld **key pair (Anmeldung)** die Option **Bestehendes Schlüsselpaar auswählen** aus. **Wählen Sie in der Drop-down-Liste key pair** auswählen das Amazon EC2 EC2-Instance-Schlüsselpaar aus, das Sie in den vorherigen Schritten erstellt oder verwendet haben.

1. Wählen Sie im Dialogfeld **Netzwerkeinstellungen** die Option **Virtual Public Cloud (VPC)** aus.

   Wählen Sie in der Dropdownliste **Sicherheitsgruppen** die Sicherheitsgruppe aus, die Sie im [Abschnitt Voraussetzungen des Tutorials](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-auto-scaling-group-prerequisites.html) erstellt haben ()**CodeDeployDemo-AS-SG**.

1. Erweitern Sie das Dialogfeld „**Erweiterte Details**“. **Wählen Sie in der Dropdownliste für das **IAM-Instanzprofil** unter IAM-Instanzprofil die IAM-Rolle aus, die Sie zuvor erstellt haben (**CodeDeployDemo-EC2-Instance-Profile**).**

   Behalten Sie die restlichen Standardeinstellungen bei.

1. Wählen Sie **Startvorlage erstellen**.

1. Wählen Sie im Dialogfeld „**Nächste Schritte**“ die Option **Auto Scaling Scaling-Gruppe erstellen** aus.

1. Geben Sie auf der Seite **Startvorlage oder Konfiguration auswählen** den **Namen der Auto Scaling Scaling-Gruppe** ein**CodeDeployDemo-AS-Group**.

1. Im Dialogfeld **Startvorlage** sollte Ihre Startvorlage (**CodeDeployDemo-AS-Launch-Template**) ausgefüllt sein. Falls nicht, wählen Sie sie aus dem Dropdownmenü aus. **Behalten Sie die Standardeinstellungen bei und wählen Sie Weiter.** 

1. **Wählen Sie auf der Seite „Instance-Startoptionen** auswählen“ im Bereich **Netzwerk** für **VPC** die Standard-VPC aus. Wählen Sie dann für **Availability Zones und Subnetze** ein Standardsubnetz aus. Sie müssen eine VPC erstellen, wenn Sie den Standard nicht wählen können. Weitere Informationen finden Sie unter [Erste Schritte mit Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-getting-started.html).

1. Verwenden Sie im Abschnitt **Instance type requirements** (Anforderungen an den Instance-Typ) die Standardeinstellung, um diesen Schritt zu vereinfachen. (Setzen Sie die Startvorlage nicht außer Kraft.) In diesem Tutorial werden Sie nur On-Demand-Instances mit dem in Ihrer Startvorlage angegebenen Instance-Typ starten.

1. Wählen Sie **Next** (Weiter), um zur Seite **Configure advanced options** (Erweiterte Optionen konfigurieren) zu gelangen.

1. Behalten Sie die Standardwerte bei und wählen Sie **Weiter**.

1. Behalten Sie auf der Seite **Gruppengröße und Skalierungsrichtlinien konfigurieren** die Standardwerte für **Gruppengröße** von 1 bei. Wählen Sie **Weiter** aus.

1. Überspringen Sie den Schritt zur Konfiguration von Benachrichtigungen und wählen Sie **Weiter**.

1. **Fügen Sie auf der Seite Tags** hinzufügen ein Tag hinzu, das bei der späteren Installation des CodeDeploy Agenten verwendet werden soll. Wählen Sie **Add tag**.

   1. Geben Sie für **Key (Schlüssel)** **Name** ein.

   1. Geben Sie unter **Value (Wert)** **CodeDeployDemo** ein.

   Wählen Sie **Weiter** aus.

1. Überprüfen Sie Ihre Auto Scaling Scaling-Gruppeninformationen auf der **Überprüfungsseite** und wählen Sie dann **Auto Scaling Scaling-Gruppe erstellen**.

1. Wählen Sie in der Navigationsleiste, wenn **Auto Scaling Scaling-Gruppen** ausgewählt sind**CodeDeployDemo-AS-Group**, und wählen Sie dann die Registerkarte **Instanzverwaltung** aus. Fahren Sie erst fort, wenn der Wert von **InService**in der Spalte **Lifecycle** und der Wert **Healthy** in der Spalte **Health Status** angezeigt wird.

1. Installieren Sie den CodeDeploy Agenten, indem Sie den Schritten unter [ CodeDeploy Agent installieren](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent-operations-install.html) folgen und die `Name=CodeDeployDemo` Instanz-Tags verwenden.

# Schritt 2: Bereitstellen der Anwendung in der Auto Scaling Scaling-Gruppe
<a name="tutorials-auto-scaling-group-create-deployment"></a>

In diesem Schritt stellen Sie die Revision für die einzelne Amazon EC2 EC2-Instance in der Auto Scaling Scaling-Gruppe bereit.

**Topics**
+ [So erstellen Sie die Bereitstellung (CLI)](#tutorials-auto-scaling-group-create-deployment-cli)
+ [So erstellen Sie die Bereitstellung (Konsole)](#tutorials-auto-scaling-group-create-deployment-console)

## So erstellen Sie die Bereitstellung (CLI)
<a name="tutorials-auto-scaling-group-create-deployment-cli"></a>

1. Rufen Sie den Befehl **create-application** zum Erstellen einer Anwendung mit dem Namen **SimpleDemoApp** auf:

   ```
   aws deploy create-application --application-name SimpleDemoApp
   ```

1. Sie sollten bereits eine Servicerolle anhand der Anweisungen unter [Schritt 2: Erstellen Sie eine Servicerolle für CodeDeploy](getting-started-create-service-role.md) erstellt haben. Die Service-Rolle CodeDeploy erteilt Ihnen die Erlaubnis, auf Ihre Amazon EC2 EC2-Instances zuzugreifen, um deren Tags zu erweitern (zu lesen). Sie benötigen den ARN der Servicerolle. Zum Abrufen des Servicerollen-ARN befolgen Sie die Anweisungen unter [Rufen Sie die Servicerolle ARN (CLI) ab](getting-started-create-service-role.md#getting-started-get-service-role-cli).

1. Nachdem Sie über einen Dienstrollen-ARN verfügen, rufen Sie den **create-deployment-group** Befehl auf, um eine Bereitstellungsgruppe mit dem Namen**SimpleDemoDG**, die der genannten Anwendung zugeordnet ist**SimpleDemoApp**, mithilfe der Auto Scaling Scaling-Gruppe mit dem Namen **CodeDeployDemo-AS-Group** und der angegebenen Bereitstellungskonfiguration mit dem angegebenen Dienstrollen-ARN zu erstellen. **CodeDeployDefault.OneAtATime**
**Anmerkung**  
Der [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)Befehl bietet Unterstützung für die Erstellung von Triggern, die zum Senden von Amazon SNS SNS-Benachrichtigungen an Themenabonnenten über bestimmte Ereignisse in Bereitstellungen und Instances führen. Der Befehl unterstützt auch Optionen für das automatische Rollback von Bereitstellungen und die Einrichtung von Alarmen, um Bereitstellungen zu beenden, wenn die Überwachungsschwellenwerte in CloudWatch Amazon-Alarmen erreicht werden. Befehle für diese Aktionen sind in diesem Tutorial nicht enthalten.

   Auf lokalen Linux-, macOS- oder Unix-Computern:

   ```
   aws deploy create-deployment-group \
     --application-name SimpleDemoApp \
     --auto-scaling-groups CodeDeployDemo-AS-Group \
     --deployment-group-name SimpleDemoDG \
     --deployment-config-name CodeDeployDefault.OneAtATime \
     --service-role-arn service-role-arn
   ```

   Auf lokalen Computern mit Windows:

   ```
   aws deploy create-deployment-group --application-name SimpleDemoApp --auto-scaling-groups CodeDeployDemo-AS-Group --deployment-group-name SimpleDemoDG --deployment-config-name CodeDeployDefault.OneAtATime --service-role-arn service-role-arn
   ```

1. Rufen Sie den Befehl **create-deployment** zum Erstellen einer Bereitstellung auf, die der Anwendung **SimpleDemoApp**, der Bereitstellungskonfiguration **CodeDeployDefault.OneAtATime** und der Bereitstellungsgruppe **SimpleDemoDG** unter Verwendung der Revision am angegebenen Speicherort zugeordnet wird.

   **Für Amazon Linux- und RHEL Amazon EC2 EC2-Instances, Aufrufe von lokalen Linux-, macOS- oder Unix-Computern**

    

   ```
   aws deploy create-deployment \
     --application-name SimpleDemoApp \
     --deployment-config-name CodeDeployDefault.OneAtATime \
     --deployment-group-name SimpleDemoDG \
     --s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Linux.zip
   ```

   *bucket-name*ist der Name des Amazon S3 S3-Buckets, der die CodeDeploy Resource Kit-Dateien für Ihre Region enthält. Ersetzen Sie beispielsweise für die Region USA Ost (Ohio) *bucket-name* durch`aws-codedeploy-us-east-2`. Eine Liste der Bucket-Namen finden Sie unter[Bucket-Namen für das Resource Kit nach Regionen](resource-kit.md#resource-kit-bucket-names).

   **Für Amazon Linux- und RHEL Amazon EC2 EC2-Instances, Aufrufen von lokalen Windows-Computern**

    

   ```
   aws deploy create-deployment --application-name SimpleDemoApp --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name SimpleDemoDG --s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Linux.zip
   ```

   *bucket-name*ist der Name des Amazon S3 S3-Buckets, der die CodeDeploy Resource Kit-Dateien für Ihre Region enthält. Ersetzen Sie beispielsweise für die Region USA Ost (Ohio) *bucket-name* durch`aws-codedeploy-us-east-2`. Eine Liste der Bucket-Namen finden Sie unter[Bucket-Namen für das Resource Kit nach Regionen](resource-kit.md#resource-kit-bucket-names).

   **Für Windows Server Amazon EC2 EC2-Instances, Aufrufe von lokalen Linux-, macOS- oder Unix-Computern**

    

   ```
   aws deploy create-deployment \
     --application-name SimpleDemoApp \
     --deployment-config-name CodeDeployDefault.OneAtATime \
     --deployment-group-name SimpleDemoDG \
     --s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Windows.zip
   ```

   *bucket-name*ist der Name des Amazon S3 S3-Buckets, der die CodeDeploy Resource Kit-Dateien für Ihre Region enthält. Ersetzen Sie beispielsweise für die Region USA Ost (Ohio) *bucket-name* durch`aws-codedeploy-us-east-2`. Eine Liste der Bucket-Namen finden Sie unter[Bucket-Namen für das Resource Kit nach Regionen](resource-kit.md#resource-kit-bucket-names).

   **Für Windows Server Amazon EC2 EC2-Instances, Aufrufen von lokalen Windows-Computern**

   ```
   aws deploy create-deployment --application-name SimpleDemoApp --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name SimpleDemoDG --s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Windows.zip
   ```

   *bucket-name*ist der Name des Amazon S3 S3-Buckets, der die CodeDeploy Resource Kit-Dateien für Ihre Region enthält. Ersetzen Sie beispielsweise für die Region USA Ost (Ohio) *bucket-name* durch`aws-codedeploy-us-east-2`. Eine Liste der Bucket-Namen finden Sie unter[Bucket-Namen für das Resource Kit nach Regionen](resource-kit.md#resource-kit-bucket-names).
**Anmerkung**  
Derzeit CodeDeploy bietet es keine Beispielversion für die Bereitstellung auf Ubuntu Server Amazon EC2 EC2-Instances. Informationen zum eigenen Erstellen einer Revision finden Sie unter [Arbeiten mit Anwendungsrevisionen für CodeDeploy](application-revisions.md).

1. Rufen Sie den Befehl **get-deployment** auf, um sicherzustellen, dass die Bereitstellung erfolgreich war.

   Bevor Sie diesen Befehl aufrufen, benötigen Sie die ID der Bereitstellung, die vom Aufruf des Befehls **create-deployment** zurückgegeben worden sein sollte. Wenn Sie die Bereitstellungs-ID erneut benötigen, rufen Sie den Befehl **list-deployments** für die Anwendung **SimpleDemoApp** und die Bereitstellungsgruppe **SimpleDemoDG** auf:

   ```
   aws deploy list-deployments --application-name SimpleDemoApp --deployment-group-name SimpleDemoDG --query "deployments" --output text
   ```

   Rufen Sie nun den Befehl **get-deployment** mit der Bereitstellungs-ID auf:

   ```
   aws deploy get-deployment --deployment-id deployment-id --query "deploymentInfo.status" --output text
   ```

   Fahren Sie erst fort, wenn der zurückgegebene Wert `Succeeded` ist.

## So erstellen Sie die Bereitstellung (Konsole)
<a name="tutorials-auto-scaling-group-create-deployment-console"></a>

1. Sie sollten bereits eine Servicerolle anhand der Anweisungen unter [Schritt 2: Erstellen Sie eine Servicerolle für CodeDeploy](getting-started-create-service-role.md) erstellt haben. Die Service-Rolle CodeDeploy erteilt Ihnen die Erlaubnis, auf Ihre Instances zuzugreifen, um deren Tags zu erweitern (zu lesen). Bevor Sie die CodeDeploy Konsole zum Bereitstellen Ihrer Anwendungsrevision verwenden, benötigen Sie die Dienstrolle ARN. Zum Abrufen des Servicerollen-ARN befolgen Sie die Anweisungen unter [Rufen Sie die Servicerolle ARN ab (Konsole)](getting-started-create-service-role.md#getting-started-get-service-role-console). 

1. Da Sie nun über die Dienstrolle ARN verfügen, können Sie die CodeDeploy Konsole verwenden, um Ihre Anwendungsrevision bereitzustellen.

   Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

1. Wählen Sie **Create application** aus.

1. Wählen Sie **Custom application (Benutzerdefinierte Anwendung)**.

1. Geben Sie unter **Application name (Anwendungsname)** **SimpleDemoApp** ein.

1. Wählen Sie unter **Compute Platform (Plattform für die Datenverarbeitung)** die Option **EC2/On-premises (EC2/Lokal)** aus.

1. Wählen Sie **Create application** aus.

1. Wählen Sie auf der Registerkarte **Deployment groups (Bereitstellungsgruppen)**, die Option **Create deployment group (Bereitstellungsgruppe erstellen)** aus.

1. Geben Sie unter **Deployment group name (Name der Bereitstellungsgruppe)** **SimpleDemoDG** ein.

1. Wählen Sie unter **Service Role (Servicerolle)** den Namen Ihrer Servicerolle aus.

1. Wählen Sie unter **Deployment type (Bereitstellungstyp)** die Option **In-place (Lokal)** aus.

1. Wählen Sie in der **Umgebungskonfiguration** **Auto Scaling Scaling-Gruppen** aus und wählen Sie dann**CodeDeployDemo-AS-Group**.

1. Wählen Sie unter **Bereitstellungskonfiguration** die Option aus **CodeDeployDefault. OneAtATime**.

1. Deaktivieren Sie **Enable load balancing (Load Balancing aktivieren)**.

1. Wählen Si **Create deployment group (Bereitstellungsgruppe erstellen)**. 

1. Klicken Sie auf der Seite der Bereitstellungsgruppe auf **Create deployment (Bereitstellung erstellen)**.

1. Wählen Sie unter **Revisionstyp** die Option **Meine Anwendung ist in Amazon S3 gespeichert** aus. 

1. Geben Sie unter **Revision location (Speicherort der Revision)** den Speicherort der Beispielanwendung für Ihr Betriebssystem und Ihre Region ein.

   **Für Amazon Linux- und RHEL Amazon EC2 EC2-Instances**  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/tutorials-auto-scaling-group-create-deployment.html)

   **Für Windows Server Amazon EC2 EC2-Instances**  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/tutorials-auto-scaling-group-create-deployment.html)

    **Für Ubuntu Server Amazon EC2 EC2-Instances**

   Geben Sie den Speicherort Ihrer benutzerdefinierten Anwendungsversion ein, die in Amazon S3 gespeichert ist.

1. Lassen Sie das Feld **Deployment description (Bereitstellungsbeschreibung)** leer.

1. Erweitern Sie **Advanced (Erweitert)**.

1. Wählen Sie **Create deployment**. 
**Anmerkung**  
Wenn **Failed (Fehlgeschlagen)** anstelle von **Succeeded (Erfolgreich)** angezeigt wird, sollten Sie einige der Methoden in [Überwachen Sie Ihre Bereitstellung und beheben Sie Fehler](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor) (mit dem Anwendungsnamen **SimpleDemoApp** und dem Bereitstellungsgruppennamen **SimpleDemoDG**) ausprobieren.

# Schritt 3: Überprüfen Sie Ihre Ergebnisse
<a name="tutorials-auto-scaling-group-verify"></a>

In diesem Schritt überprüfen Sie, ob die **SimpleDemoApp** Version auf der einzelnen Amazon EC2 EC2-Instance in der Auto Scaling Scaling-Gruppe CodeDeploy installiert wurde.

**Topics**
+ [So prüfen Sie die Ergebnisse (CLI)](#tutorials-auto-scaling-group-verify-cli)
+ [So prüfen Sie die Ergebnisse (Konsole)](#tutorials-auto-scaling-group-verify-console)

## So prüfen Sie die Ergebnisse (CLI)
<a name="tutorials-auto-scaling-group-verify-cli"></a>

Zunächst benötigen Sie das öffentliche DNS der Amazon EC2 EC2-Instance.

Verwenden Sie die AWS CLI , um das öffentliche DNS der Amazon EC2 EC2-Instance in der Auto Scaling Scaling-Gruppe abzurufen, indem **describe-instances** Sie den Befehl aufrufen. 

Bevor Sie diesen Befehl aufrufen, benötigen Sie die ID der Amazon EC2 EC2-Instance. Zum Anfordern der ID rufen Sie wie bereits zuvor den **describe-auto-scaling-groups** für **CodeDeployDemo-AS-Group** auf:

```
aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].InstanceId" --output text
```

Rufen Sie nun den Befehl **describe-instances** auf:

```
aws ec2 describe-instances --instance-id instance-id --query "Reservations[0].Instances[0].PublicDnsName" --output text
```

Der zurückgegebene Wert ist das öffentliche DNS der Amazon EC2 EC2-Instance.

Zeigen Sie mit einem Webbrowser die für diese Amazon EC2 EC2-Instance bereitgestellte SimpleDemoApp Version an, und verwenden Sie dabei eine URL wie die folgende:

```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```

Wenn Sie die Seite mit den Glückwünschen sehen, haben Sie erfolgreich eine Revision CodeDeploy für eine einzelne Amazon EC2 EC2-Instance in einer Auto Scaling Scaling-Gruppe bereitgestellt\$1

Als Nächstes fügen Sie der Auto Scaling Scaling-Gruppe eine Amazon EC2 EC2-Instance hinzu. Nachdem Amazon EC2 Auto Scaling die Amazon EC2 EC2-Instance hinzugefügt hat, CodeDeploy wird Ihre Revision auf der neuen Instance bereitgestellt.

## So prüfen Sie die Ergebnisse (Konsole)
<a name="tutorials-auto-scaling-group-verify-console"></a>

Zunächst benötigen Sie das öffentliche DNS der Amazon EC2 EC2-Instance.

Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

Wählen Sie im Amazon EC2 EC2-Navigationsbereich unter **Auto Scaling** die Option **Auto Scaling Groups** und dann den **CodeDeployDemo-AS-Group** Eintrag aus.

Wählen Sie auf der Registerkarte **Instances** die Amazon EC2 EC2-Instance-ID in der Liste aus.

Notieren Sie sich auf der Seite **Instances** auf der Registerkarte **Description** den **Public DNS**-Wert. Sie sollte wie folgt aussehen: **ec2-01-234-567-890.compute-1.amazonaws.com**.

Zeigen Sie mit einem Webbrowser die für diese Amazon EC2 EC2-Instance bereitgestellte SimpleDemoApp Version an, und verwenden Sie dabei eine URL wie die folgende:

```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```

Wenn Sie die Seite mit den Glückwünschen sehen, haben Sie erfolgreich eine Revision CodeDeploy für eine einzelne Amazon EC2 EC2-Instance in einer Auto Scaling Scaling-Gruppe bereitgestellt\$1

Als Nächstes fügen Sie der Auto Scaling Scaling-Gruppe eine Amazon EC2 EC2-Instance hinzu. Nachdem Amazon EC2 Auto Scaling die Amazon EC2 EC2-Instance hinzugefügt hat, CodeDeploy wird Ihre Version auf der neuen Amazon EC2 EC2-Instance bereitgestellt.

# Schritt 4: Erhöhen Sie die Anzahl der Amazon EC2 EC2-Instances in der Auto Scaling Scaling-Gruppe
<a name="tutorials-auto-scaling-group-scale-up"></a>

In diesem Schritt weisen Sie die Auto Scaling Scaling-Gruppe an, eine zusätzliche Amazon EC2 EC2-Instance zu erstellen. Nachdem Amazon EC2 Auto Scaling die Instance erstellt hat, CodeDeploy stellt es Ihre Revision darauf bereit.

**Topics**
+ [Um die Anzahl der Amazon EC2 EC2-Instances in der Auto Scaling-Gruppe (CLI) zu skalieren](#tutorials-auto-scaling-group-scale-up-cli)
+ [Um die Anzahl der Amazon EC2 EC2-Instances in der Bereitstellungsgruppe (Konsole) zu skalieren](#tutorials-auto-scaling-group-scale-up-console)

## Um die Anzahl der Amazon EC2 EC2-Instances in der Auto Scaling-Gruppe (CLI) zu skalieren
<a name="tutorials-auto-scaling-group-scale-up-cli"></a>

1. Rufen Sie den **update-auto-scaling-group** Befehl auf, um die Anzahl der Amazon EC2-Instances in der Auto Scaling Scaling-Gruppe **CodeDeployDemo-AS-Group** von eins auf zwei zu erhöhen.

   Auf lokalen Linux-, macOS- oder Unix-Computern:

   ```
   aws autoscaling update-auto-scaling-group \
     --auto-scaling-group-name CodeDeployDemo-AS-Group \
     --min-size 2 \
     --max-size 2 \
     --desired-capacity 2
   ```

   Auf lokalen Computern mit Windows:

   ```
   aws autoscaling update-auto-scaling-group --auto-scaling-group-name CodeDeployDemo-AS-Group --min-size 2 --max-size 2 --desired-capacity 2
   ```

1. Stellen Sie sicher, dass die Auto Scaling Scaling-Gruppe jetzt über zwei Amazon EC2 EC2-Instances verfügt. Rufen Sie den Befehl **describe-auto-scaling-groups** für **CodeDeployDemo-AS-Group** auf:

   ```
   aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].[HealthStatus, LifecycleState]" --output text
   ```

   Fahren Sie erst fort, wenn die beiden zurückgegebenen Werte `Healthy` und `InService` anzeigen.

## Um die Anzahl der Amazon EC2 EC2-Instances in der Bereitstellungsgruppe (Konsole) zu skalieren
<a name="tutorials-auto-scaling-group-scale-up-console"></a>

1. Wählen Sie in der Amazon EC2 EC2-Navigationsleiste unter **Auto Scaling** die Option **Auto Scaling Groups** und dann. **CodeDeployDemo-AS-Group**

1. Wählen Sie **Actions** und anschließend **Bearbeiten**.

1. Geben Sie auf der Registerkarte **Details** in den Feldern **Desired (Gewünscht)**, **Min** und **Max** den Wert **2** ein. Klicken Sie dann auf **Save (Speichern)**.

1. Wählen Sie die Registerkarte **Instances** aus. Die neue Amazon EC2 EC2-Instance sollte in der Liste erscheinen. (Wenn die Instance nicht angezeigt wird, müssen Sie möglicherweise ein paar Mal auf die Schaltfläche **Refresh** klicken.) Fahren Sie erst fort, wenn der Wert von **InService**in der Spalte **Lifecycle** und der Wert **Healthy** in der Spalte **Health Status** angezeigt wird.

# Schritt 5: Überprüfen Sie Ihre Ergebnisse erneut
<a name="tutorials-auto-scaling-group-reverify"></a>

In diesem Schritt überprüfen Sie, ob die SimpleDemoApp Revision auf der neuen Instance in der Auto Scaling Scaling-Gruppe CodeDeploy installiert ist.

**Topics**
+ [So prüfen Sie die Ergebnisse der automatischen Bereitstellung (CLI)](#tutorials-auto-scaling-group-reverify-cli)
+ [So prüfen Sie die Ergebnisse der automatischen Bereitstellung (Konsole)](#tutorials-auto-scaling-group-reverify-console)

## So prüfen Sie die Ergebnisse der automatischen Bereitstellung (CLI)
<a name="tutorials-auto-scaling-group-reverify-cli"></a>

1. Bevor Sie den Befehl **get-deployment** aufrufen, benötigen Sie die ID der automatischen Bereitstellung. Um die ID abzurufen, rufen Sie den Befehl **list-deployments** für die Anwendung **SimpleDemoApp** und die Bereitstellungsgruppe **SimpleDemoDG** auf:

   ```
   aws deploy list-deployments --application-name SimpleDemoApp --deployment-group-name SimpleDemoDG --query "deployments" --output text
   ```

   Es sollte zwei Bereitstellungen geben IDs. Verwenden Sie die ID, die Sie noch nicht in einem Aufruf des Befehls **get-deployment** verwendet haben:

   ```
   aws deploy get-deployment --deployment-id deployment-id --query "deploymentInfo.[status, creator]" --output text
   ```

   Zusätzlich zum Bereitstellungsstatus sollten Sie dies `autoScaling` in der Befehlsausgabe sehen. (`autoScaling`bedeutet, dass Amazon EC2 Auto Scaling die Bereitstellung erstellt hat.) 

   Fahren Sie erst fort, wenn der Bereitstellungsstatus `Succeeded` zeigt.

1. Bevor Sie den **describe-instances** Befehl aufrufen, benötigen Sie die ID der neuen Amazon EC2 EC2-Instance. Zum Abrufen dieser ID rufen Sie erneut den Befehl **describe-auto-scaling-groups** für **CodeDeployDemo-AS-Group** auf:

   ```
   aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].InstanceId" --output text
   ```

   Rufen Sie nun den Befehl **describe-instances** auf:

   ```
   aws ec2 describe-instances --instance-id instance-id --query "Reservations[0].Instances[0].PublicDnsName" --output text
   ```

   Notieren Sie sich in der Ausgabe des **describe-instances** Befehls den öffentlichen DNS für die neue Amazon EC2 EC2-Instance.

1. Zeigen Sie mit einem Webbrowser die für diese Amazon EC2 EC2-Instance bereitgestellte `SimpleDemoApp` Version an, und verwenden Sie dabei eine URL wie die folgende:

   ```
   http://ec2-01-234-567-890.compute-1.amazonaws.com
   ```

   Wenn die Seite mit den Glückwünschen angezeigt wird, haben Sie früher eine Revision CodeDeploy für eine skalierte Amazon EC2 EC2-Instance in einer Auto Scaling Scaling-Gruppe bereitgestellt\$1

## So prüfen Sie die Ergebnisse der automatischen Bereitstellung (Konsole)
<a name="tutorials-auto-scaling-group-reverify-console"></a>

1. [Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter /codedeploy. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Bereitstellungen** aus.

   

1. Wählen Sie die Bereitstellungs-ID der Bereitstellung, die Amazon EC2 Auto Scaling erstellt hat.

   .

1.  Auf der Seite **Deployment (Bereitstellung)** werden Informationen über die Bereitstellung angezeigt. Normalerweise würden Sie selbst eine Bereitstellung erstellen, aber Amazon EC2 Auto Scaling hat eine in Ihrem Namen erstellt, um Ihre Version auf der neuen Amazon EC2-Instance bereitzustellen.

1. Sobald als Bereitstellungsstatus oben auf der Seite **Succeeded (Erfolgreich)** angezeigt wird, überprüfen Sie die Ergebnisse für die Instance. Sie müssen zunächst den öffentlichen DNS der Instance abrufen:

1. Wählen Sie im Amazon EC2 EC2-Navigationsbereich unter **Auto Scaling** die Option **Auto Scaling Groups** und dann den **CodeDeployDemo-AS-Group** Eintrag aus.

1. Wählen Sie auf der Registerkarte **Instances** die ID der neuen Amazon EC2 EC2-Instance aus.

1. Notieren Sie sich auf der Seite **Instances** auf der Registerkarte **Description** den **Public DNS**-Wert. Sie sollte wie folgt aussehen: **ec2-01-234-567-890.compute-1.amazonaws.com**.

Zeigen Sie die Revision `SimpleDemoApp`, die für die Instanz bereitgestellt wurde, über eine URL wie die folgende an:

```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```

Wenn die Seite mit den Glückwünschen angezeigt wird, haben Sie früher eine Revision CodeDeploy für eine skalierte Amazon EC2 EC2-Instance in einer Auto Scaling Scaling-Gruppe bereitgestellt\$1

# Schritt 6: Bereinigen
<a name="tutorials-auto-scaling-group-clean-up"></a>

In diesem Schritt löschen Sie die Auto Scaling Scaling-Gruppe, um laufende Gebühren für Ressourcen zu vermeiden, die Sie in diesem Tutorial verwendet haben. Optional können Sie die Auto Scaling Scaling-Konfiguration und die CodeDeploy Deployment-Komponentendatensätze löschen.

**Topics**
+ [So bereinigen Sie die Ressourcen (CLI):](#tutorials-auto-scaling-group-clean-up-cli)
+ [So bereinigen Sie Ressourcen (Konsole):](#tutorials-auto-scaling-group-clean-up-console)

## So bereinigen Sie die Ressourcen (CLI):
<a name="tutorials-auto-scaling-group-clean-up-cli"></a>

1. Löschen Sie die Auto Scaling Scaling-Gruppe, indem **delete-auto-scaling-group** Sie den Befehl gegen aufrufen**CodeDeployDemo-AS-Group**. Dadurch werden auch die Amazon EC2-Instances beendet. 

   ```
   aws autoscaling delete-auto-scaling-group --auto-scaling-group-name CodeDeployDemo-AS-Group --force-delete
   ```

1. Löschen Sie optional die Auto Scaling Scaling-Startvorlage, indem Sie den **delete-launch-template** Befehl für die Startkonfiguration mit dem Namen aufrufen**CodeDeployDemo-AS-Launch-Template**:

   ```
   aws ec2 delete-launch-template --launch-template-name CodeDeployDemo-AS-Launch-Template
   ```

1. Löschen Sie optional die Anwendung von, CodeDeploy indem Sie den **delete-application** Befehl für die angegebene Anwendung aufrufen**SimpleDemoApp**. Dadurch werden auch alle zugehörigen Bereitstellungs-, Bereitstellungsgruppen- und Revisions-Datensätze gelöscht. 

   ```
   aws deploy delete-application --application-name SimpleDemoApp
   ```

1. Rufen Sie den **delete-association** Befehl auf, um die Systems Manager State Manager-Zuordnung zu löschen.

   ```
   aws ssm delete-association --assocation-id association-id
   ```

   Sie können den abrufen, *association-id* indem Sie den **describe-association** Befehl aufrufen.

   ```
   aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
   ```

## So bereinigen Sie Ressourcen (Konsole):
<a name="tutorials-auto-scaling-group-clean-up-console"></a>

Um die Auto Scaling Scaling-Gruppe zu löschen, die auch die Amazon EC2 EC2-Instances beendet, gehen Sie wie folgt vor:

1. 

   Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie im Amazon EC2 EC2-Navigationsbereich unter **Auto Scaling** die Option **Auto Scaling Groups** und dann den **CodeDeployDemo-AS-Group** Eintrag aus.

1. Wählen Sie **Actions**, wählen Sie **Delete** und dann **Yes, Delete**.

(Optional) Um die Startvorlage zu löschen:

1.  Wählen Sie in der Navigationsleiste unter **Auto Scaling** die Option **Konfigurationen starten** und wählen Sie dann**CodeDeployDemo-AS-Launch-Template**.

1. Wählen Sie **Actions**, wählen Sie **Delete launch configuration** und dann **Yes, Delete**.

1. Löschen Sie optional die Anwendung von CodeDeploy. Dadurch werden auch alle zugehörigen Bereitstellungs-, Bereitstellungsgruppen- und Revisions-Datensätze gelöscht. Öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).

1. [Melden Sie sich bei /codedeploy an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

   Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

   

1. Wählen Sie aus der Liste der Anwendungen **SimpleDemoApp** aus.

1. Wählen Sie auf der Seite **Application details** die Option **Delete application**.

1. Geben Sie bei der Aufforderung **Delete** ein und klicken Sie dann auf **Delete (Löschen)**. 

So löschen Sie die Systems Manager State Manager-Zuordnung:

1. Öffnen Sie die AWS Systems Manager Konsole unter https://console.aws.amazon.com /systems-manager.

1. Wählen Sie im Navigationsbereich **Statusmanager** aus.

1. Wählen Sie die Verknüpfung aus, die Sie erstellt haben, und wählen Sie **Delete (Löschen)** aus.

# Tutorial: Verwenden Sie CodeDeploy zum Bereitstellen einer Anwendung von GitHub
<a name="tutorials-github"></a>

In diesem Tutorial verwenden Sie, CodeDeploy um eine Beispielanwendungsrevision von GitHub für eine einzelne Amazon EC2 EC2-Instance bereitzustellen, auf der Amazon Linux ausgeführt wird, eine einzelne Red Hat Enterprise Linux (RHEL) -Instance oder eine einzelne Windows Server-Instance. Informationen zur GitHub Integration mit CodeDeploy finden Sie unter. [Integrieren CodeDeploy mit GitHub](integrations-partners-github.md)

**Anmerkung**  
Sie können es auch verwenden CodeDeploy , um eine Anwendungsversion von GitHub auf einer Ubuntu Server-Instanz bereitzustellen. Sie können die unter beschriebene Beispielrevision verwenden oder eine Version erstellen[Tutorial: Bereitstellen einer Anwendung auf einer lokalen Instanz mit CodeDeploy (Windows Server, Ubuntu Server oder Red Hat Enterprise Linux)](tutorials-on-premises-instance.md), die mit einer Ubuntu-Server-Instanz und kompatibel ist CodeDeploy. [Schritt 2: Erstellen Sie eine Version der Beispielanwendung](tutorials-on-premises-instance-2-create-sample-revision.md) Wie Sie eine eigene Revision erstellen, erfahren Sie unter [Planen Sie eine Revision für CodeDeploy](application-revisions-plan.md) und [Hinzufügen einer Anwendungsspezifikationsdatei zu einer Revision für CodeDeploy](application-revisions-appspec-file.md).

**Topics**
+ [Voraussetzungen](tutorials-github-prerequisites.md)
+ [Schritt 1: Richten Sie ein GitHub Konto ein](tutorials-github-create-github-account.md)
+ [Schritt 2: Erstellen Sie ein GitHub Repository](tutorials-github-create-github-repository.md)
+ [Schritt 3: Laden Sie eine Beispielanwendung in Ihr GitHub Repository hoch](tutorials-github-upload-sample-revision.md)
+ [Schritt 4: Stellen Sie eine Instanz bereit](tutorials-github-provision-instance.md)
+ [Schritt 5: Erstellen Sie eine Anwendung und eine Bereitstellungsgruppe](tutorials-github-create-application.md)
+ [Schritt 6: Stellen Sie die Anwendung auf der Instanz bereit](tutorials-github-deploy-application.md)
+ [Schritt 7: Überwachen und verifizieren Sie die Bereitstellung](tutorials-github-verify.md)
+ [Schritt 8: Bereinigen](tutorials-github-clean-up.md)

# Voraussetzungen
<a name="tutorials-github-prerequisites"></a>

Führen Sie die folgenden Schritte durch, bevor Sie mit diesem Tutorial beginnen:
+ Installieren Sie Git auf Ihrem lokalen Computer. Informationen zur Installation von Git finden Sie unter [Git-Downloads](http://git-scm.com/downloads).
+ Führen Sie die unter [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md) beschriebenen Schritte durch, einschließlich der Installation und Konfiguration der AWS CLI. Dies ist besonders wichtig, wenn Sie den verwenden möchten AWS CLI , um eine Revision von der Instanz aus GitHub bereitzustellen.

# Schritt 1: Richten Sie ein GitHub Konto ein
<a name="tutorials-github-create-github-account"></a>

Sie benötigen ein GitHub Konto, um ein GitHub Repository zu erstellen, in dem die Revision gespeichert wird. Wenn Sie bereits ein GitHub Konto haben, fahren Sie mit fort[Schritt 2: Erstellen Sie ein GitHub Repository](tutorials-github-create-github-repository.md).

1. Gehe zu [https://github.com/join](https://github.com).

1. Geben Sie einen Benutzernamen, eine E-Mail-Adresse und ein Passwort ein.

1. Wählen Sie **Anmelden für GitHub** und folgen Sie dann den Anweisungen.

# Schritt 2: Erstellen Sie ein GitHub Repository
<a name="tutorials-github-create-github-repository"></a>

Sie benötigen ein GitHub Repository, um die Revision zu speichern.

Wenn Sie bereits über ein GitHub Repository verfügen, stellen Sie sicher, dass Sie es **CodeDeployGitHubDemo** in diesem Tutorial durch seinen Namen ersetzen, und fahren Sie dann mit fort[Schritt 3: Laden Sie eine Beispielanwendung in Ihr GitHub Repository hoch](tutorials-github-upload-sample-revision.md). 

1. Führen Sie auf der [GitHub Startseite](https://github.com/dashboard) einen der folgenden Schritte aus:
   + Wählen Sie in **Your repositories** die Option **New repository**.
   + Wählen Sie auf der Navigationsleiste **Create new** (**\$1**) und dann **New repository**.

1. Gehen Sie auf der Seite **Create a new repository** wie folgt vor:
   + Geben Sie in das Textfeld **Repository name (Repository-Name)** **CodeDeployGitHubDemo** ein.
   + Wählen Sie die Option **Public** aus.
**Anmerkung**  
Die Auswahl der Standardoption **Public** bedeutet, dass alle dieses Repository sehen können. Sie können die Option **Private (Privat)** auswählen, um zu begrenzen, wer das Repository sehen und ein Commit dafür durchführen kann. 
   + Deaktivieren Sie das Kontrollkästchen **Initialize this repository with a README**. Sie werden stattdessen im nächsten Schritt manuell eine Datei namens `README.md` erstellen.
   + Wählen Sie **Repository erstellen** aus.

1. Befolgen Sie die für Ihren lokalen Computer passende Anleitung, um das Repository über die Befehlszeile zu erstellen.
**Anmerkung**  
Wenn Sie die Zwei-Faktor-Authentifizierung aktiviert haben GitHub, stellen Sie sicher, dass Sie Ihr persönliches Zugriffstoken anstelle Ihres GitHub Anmeldekennworts eingeben, wenn Sie zur Eingabe eines Kennworts aufgefordert werden. Weitere Informationen finden Sie unter [Bereitstellung Ihres 2FA-Authentifizierungscodes](https://help.github.com/articles/providing-your-2fa-authentication-code/).

**Auf lokalen Linux-, macOS- oder Unix-Computern:**

1. Führen Sie im Terminal nacheinander die folgenden Befehle aus, wobei Ihr GitHub Benutzername angegeben *user-name* ist:

   ```
   mkdir /tmp/CodeDeployGitHubDemo
   ```

   ```
   cd /tmp/CodeDeployGitHubDemo
   ```

   ```
   touch README.md
   ```

   ```
   git init
   ```

   ```
   git add README.md
   ```

   ```
   git commit -m "My first commit"
   ```

   ```
   git remote add origin https://github.com/user-name/CodeDeployGitHubDemo.git
   ```

   ```
   git push -u origin master
   ```

1. Lassen Sie unter `/tmp/CodeDeployGitHubDemo` das Terminal offen.

**Auf lokalen Computern mit Windows:**

1. Rufen Sie eine Eingabeaufforderung als Administrator auf und führen Sie nacheinander die folgenden Befehle aus:

   ```
   mkdir c:\temp\CodeDeployGitHubDemo
   ```

   ```
   cd c:\temp\CodeDeployGitHubDemo
   ```

   ```
   notepad README.md
   ```

1. Speichern Sie die Datei `README.md` im Editor. Schließen Sie den Editor. Führen Sie nacheinander die folgenden Befehle aus, wobei Ihr GitHub Benutzername angegeben *user-name* ist:

   ```
   git init
   ```

   ```
   git add README.md
   ```

   ```
   git commit -m "My first commit"
   ```

   ```
   git remote add origin https://github.com/user-name/CodeDeployGitHubDemo.git
   ```

   ```
   git push -u origin master
   ```

1. Lassen Sie unter `c:\temp\CodeDeployGitHubDemo` die Befehlszeile offen.

# Schritt 3: Laden Sie eine Beispielanwendung in Ihr GitHub Repository hoch
<a name="tutorials-github-upload-sample-revision"></a>

In diesem Schritt kopieren Sie eine Beispielrevision aus einem öffentlichen Amazon S3 S3-Bucket in Ihr GitHub Repository. (Der Einfachheit halber handelt es sich bei den für dieses Tutorial bereitgestellten Beispielrevisionen um einzelne Webseiten.)

**Anmerkung**  
Falls Sie statt unserer Beispielrevision eine eigene Revision verwenden möchten, gilt für diese Revision Folgendes:   
Sie muss die unter [Planen Sie eine Revision für CodeDeploy](application-revisions-plan.md) und [Hinzufügen einer Anwendungsspezifikationsdatei zu einer Revision für CodeDeploy](application-revisions-appspec-file.md) beschriebenen Richtlinien erfüllen.
Sie muss mit dem ausgewählten Instance-Typ kompatibel sein.
Seien Sie von Ihrem GitHub Dashboard aus zugänglich.
Wenn Ihre Revision diese Anforderungen erfüllt, können Sie direkt mit [Schritt 5: Erstellen Sie eine Anwendung und eine Bereitstellungsgruppe](tutorials-github-create-application.md) fortfahren.  
Wenn Sie auf einer Ubuntu Server-Instanz bereitstellen, müssen Sie eine Version, die mit einer Ubuntu-Server-Instanz kompatibel ist, in Ihr GitHub Repository hochladen und CodeDeploy. Weitere Informationen erhalten Sie unter [Planen Sie eine Revision für CodeDeploy](application-revisions-plan.md) und [Hinzufügen einer Anwendungsspezifikationsdatei zu einer Revision für CodeDeploy](application-revisions-appspec-file.md).

**Topics**
+ [Eine Beispielrevision von einem lokalen Linux-, macOS- oder Unix-Computer übertragen](#tutorials-github-upload-sample-revision-unixes)
+ [Übertragen einer Beispielrevision per Push von einem lokalen Computer mit Windows](#tutorials-github-upload-sample-revision-windows)

## Eine Beispielrevision von einem lokalen Linux-, macOS- oder Unix-Computer übertragen
<a name="tutorials-github-upload-sample-revision-unixes"></a>

Führen Sie bei geöffnetem Terminal, beispielsweise unter `/tmp/CodeDeployGitHubDemo` nacheinander die nachfolgenden Befehle aus. 

**Anmerkung**  
Wenn Sie die Bereitstellung auf einer Windows Server-Instanz planen, ersetzen `SampleApp_Windows.zip` Sie dies `SampleApp_Linux.zip` in den Befehlen.

```
(Amazon S3 copy command)
```

```
unzip SampleApp_Linux.zip
```

```
rm SampleApp_Linux.zip
```

 

```
git add .
```

```
git commit -m "Added sample app"
```

```
git push
```

Wo *(Amazon S3 copy command)* ist einer der folgenden: 
+ `aws s3 cp s3://aws-codedeploy-us-east-2/samples/latest/SampleApp_Linux.zip . --region us-east-2`für die Region USA Ost (Ohio)
+ `aws s3 cp s3://aws-codedeploy-us-east-1/samples/latest/SampleApp_Linux.zip . --region us-east-1`für die Region USA Ost (Nord-Virginia)
+ `aws s3 cp s3://aws-codedeploy-us-west-1/samples/latest/SampleApp_Linux.zip . --region us-west-1` für die Region USA West (Nordkalifornien)
+ `aws s3 cp s3://aws-codedeploy-us-west-2/samples/latest/SampleApp_Linux.zip . --region us-west-2`für die Region USA West (Oregon)
+ `aws s3 cp s3://aws-codedeploy-ca-central-1/samples/latest/SampleApp_Linux.zip . --region ca-central-1`für die Region Kanada (Zentral)
+ `aws s3 cp s3://aws-codedeploy-eu-west-1/samples/latest/SampleApp_Linux.zip . --region eu-west-1`für die Region Europa (Irland) 
+ `aws s3 cp s3://aws-codedeploy-eu-west-2/samples/latest/SampleApp_Linux.zip . --region eu-west-2`für die Region Europa (London) 
+ `aws s3 cp s3://aws-codedeploy-eu-west-3/samples/latest/SampleApp_Linux.zip . --region eu-west-3`für die Region Europa (Paris) 
+ `aws s3 cp s3://aws-codedeploy-eu-central-1/samples/latest/SampleApp_Linux.zip . --region eu-central-1`für die Region Europa (Frankfurt)
+ `aws s3 cp s3://aws-codedeploy-il-central-1/samples/latest/SampleApp_Linux.zip . --region il-central-1`für die Region Israel (Tel Aviv)
+ `aws s3 cp s3://aws-codedeploy-ap-east-1/samples/latest/SampleApp_Linux.zip . --region ap-east-1`für die Region Asien-Pazifik (Hongkong)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-1/samples/latest/SampleApp_Linux.zip . --region ap-northeast-1`für die Region Asien-Pazifik (Tokio)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-2/samples/latest/SampleApp_Linux.zip . --region ap-northeast-2`für die Region Asien-Pazifik (Seoul)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-1/samples/latest/SampleApp_Linux.zip . --region ap-southeast-1`für die Region Asien-Pazifik (Singapur)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-2/samples/latest/SampleApp_Linux.zip . --region ap-southeast-2`für die Region Asien-Pazifik (Sydney)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-4/samples/latest/SampleApp_Linux.zip . --region ap-southeast-4`für die Region Asien-Pazifik (Melbourne)
+ `aws s3 cp s3://aws-codedeploy-ap-south-1/samples/latest/SampleApp_Linux.zip . --region ap-south-1`für die Region Asien-Pazifik (Mumbai)
+ `aws s3 cp s3://aws-codedeploy-sa-east-1/samples/latest/SampleApp_Linux.zip . --region sa-east-1`für die Region Südamerika (São Paulo)

## Übertragen einer Beispielrevision per Push von einem lokalen Computer mit Windows
<a name="tutorials-github-upload-sample-revision-windows"></a>

 Führen Sie bei geöffneter Befehlszeile, beispielsweise unter `c:\temp\CodeDeployGitHubDemo`, nacheinander die nachfolgenden Befehle aus.

**Anmerkung**  
Wenn Sie die Bereitstellung auf einer Amazon Linux- oder RHEL-Instance planen, ersetzen Sie dies `SampleApp_Windows.zip` in `SampleApp_Linux.zip` den Befehlen.

```
(Amazon S3 copy command)
```

Entpacken Sie den Inhalt der ZIP-Datei `the` direkt in das lokale Verzeichnis (zum Beispiel `c:\temp\CodeDeployGitHubDemo`), nicht in ein neues Unterverzeichnis.

```
git add .
```

```
git commit -m "Added sample app"
```

```
git push
```

Wo *(Amazon S3 copy command)* ist einer der folgenden: 
+ `aws s3 cp s3://aws-codedeploy-us-east-2/samples/latest/SampleApp_Windows.zip . --region us-east-2`für die Region USA Ost (Ohio)
+ `aws s3 cp s3://aws-codedeploy-us-east-1/samples/latest/SampleApp_Windows.zip . --region us-east-1`für die Region USA Ost (Nord-Virginia)
+ `aws s3 cp s3://aws-codedeploy-us-west-1/samples/latest/SampleApp_Windows.zip . --region us-west-1` für die Region USA West (Nordkalifornien)
+ `aws s3 cp s3://aws-codedeploy-us-west-2/samples/latest/SampleApp_Windows.zip . --region us-west-2`für die Region USA West (Oregon)
+ `aws s3 cp s3://aws-codedeploy-ca-central-1/samples/latest/SampleApp_Windows.zip . --region ca-central-1`für die Region Kanada (Zentral)
+ `aws s3 cp s3://aws-codedeploy-eu-west-1/samples/latest/SampleApp_Windows.zip . --region eu-west-1`für die Region Europa (Irland)
+ `aws s3 cp s3://aws-codedeploy-eu-west-2/samples/latest/SampleApp_Windows.zip . --region eu-west-2`für die Region Europa (London)
+ `aws s3 cp s3://aws-codedeploy-eu-west-3/samples/latest/SampleApp_Windows.zip . --region eu-west-3`für die Region Europa (Paris)
+ `aws s3 cp s3://aws-codedeploy-eu-central-1/samples/latest/SampleApp_Windows.zip . --region eu-central-1`für die Region Europa (Frankfurt)
+ `aws s3 cp s3://aws-codedeploy-il-central-1/samples/latest/SampleApp_Windows.zip . --region il-central-1`für die Region Israel (Tel Aviv)
+ `aws s3 cp s3://aws-codedeploy-ap-east-1/samples/latest/SampleApp_Windows.zip . --region ap-east-1`für die Region Asien-Pazifik (Hongkong)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-1/samples/latest/SampleApp_Windows.zip . --region ap-northeast-1`für die Region Asien-Pazifik (Tokio)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-2/samples/latest/SampleApp_Windows.zip . --region ap-northeast-2`für die Region Asien-Pazifik (Seoul)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-1/samples/latest/SampleApp_Windows.zip . --region ap-southeast-1`für die Region Asien-Pazifik (Singapur)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-2/samples/latest/SampleApp_Windows.zip . --region ap-southeast-2`für die Region Asien-Pazifik (Sydney)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-4/samples/latest/SampleApp_Windows.zip . --region ap-southeast-4`für die Region Asien-Pazifik (Melbourne)
+ `aws s3 cp s3://aws-codedeploy-ap-south-1/samples/latest/SampleApp_Windows.zip . --region ap-south-1`für die Region Asien-Pazifik (Mumbai)
+ `aws s3 cp s3://aws-codedeploy-sa-east-1/samples/latest/SampleApp_Windows.zip . --region sa-east-1`für die Region Südamerika (São Paulo)

Um Ihre eigene Revision auf eine Ubuntu Server-Instanz zu übertragen, kopieren Sie Ihre Revision in Ihr lokales Repo und rufen Sie dann Folgendes auf:

```
git add .
git commit -m "Added Ubuntu app"
git push
```

# Schritt 4: Stellen Sie eine Instanz bereit
<a name="tutorials-github-provision-instance"></a>

In diesem Schritt erstellen oder konfigurieren Sie die Instance, in der Sie die Beispielanwendung bereitstellen werden. Sie können die Bereitstellung auf einer Amazon EC2 EC2-Instance oder einer lokalen Instance durchführen, auf der eines der Betriebssysteme ausgeführt wird, die von unterstützt werden. CodeDeploy Weitere Informationen hierzu erhalten Sie unter [Betriebssysteme, die vom Agenten unterstützt werden CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems). (Wenn Sie bereits eine Instance für die Verwendung in CodeDeploy Bereitstellungen konfiguriert haben, fahren Sie mit dem nächsten Schritt fort.)

**Um eine Instanz bereitzustellen**

1. Folgen Sie den Anweisungen unter [Starten Sie eine Amazon EC2 EC2-Instance (Konsole)](instances-ec2-create.md#instances-ec2-create-console) So stellen Sie eine Instanz bereit.

1. Denken Sie beim Starten der Instance daran, auf der Seite **Tags hinzufügen** ein Tag anzugeben. Einzelheiten zur Angabe des Tags finden Sie unter[Starten Sie eine Amazon EC2 EC2-Instance (Konsole)](instances-ec2-create.md#instances-ec2-create-console).

**Um zu überprüfen, ob der CodeDeploy Agent auf der Instance ausgeführt wird**
+ Folgen Sie den Anweisungen unter[Stellen Sie sicher, dass der CodeDeploy Agent läuft](codedeploy-agent-operations-verify.md), um zu überprüfen, ob der Agent ausgeführt wird.

Nachdem Sie die Instanz erfolgreich bereitgestellt und überprüft haben, ob der CodeDeploy Agent ausgeführt wird, fahren Sie mit dem nächsten Schritt fort.

# Schritt 5: Erstellen Sie eine Anwendung und eine Bereitstellungsgruppe
<a name="tutorials-github-create-application"></a>

In diesem Schritt verwenden Sie die CodeDeploy Konsole oder die, AWS CLI um eine Anwendung und eine Bereitstellungsgruppe zu erstellen, mit der Sie die Beispielversion aus Ihrem GitHub Repository bereitstellen können.



## Erstellen einer Anwendung und einer Bereitstellungsgruppe (Konsole)
<a name="tutorials-github-create-application-console"></a>

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

   

1. Wählen Sie **Create application (Anwendung erstellen)** und anschließend **Custom application (Benutzerdefinierte Anwendung)**.

1. Geben Sie unter **Application name (Anwendungsname)** **CodeDeployGitHubDemo-App** ein.

1. Wählen Sie unter **Compute Platform (Plattform für die Datenverarbeitung)** die Option **EC2/On-premises (EC2/Lokal)** aus.

1. Wählen Sie **Create application** aus.

1. Wählen Sie auf der Registerkarte **Deployment groups (Bereitstellungsgruppen)**, die Option **Create deployment group (Bereitstellungsgruppe erstellen)** aus.

1. Geben Sie unter **Deployment group name (Name der Bereitstellungsgruppe)** **CodeDeployGitHubDemo-DepGrp** ein.

1. Wählen Sie **unter Servicerolle** den Namen Ihrer CodeDeploy Servicerolle aus, die Sie unter [Servicerolle erstellen für](getting-started-create-service-role.md) erstellt haben CodeDeploy.

1. Wählen Sie unter **Deployment type (Bereitstellungstyp)** die Option **In-place (Lokal)** aus.

1. Wählen Sie in der **Umgebungskonfiguration** je nach Art der Instance, die Sie verwenden, **Amazon EC2 EC2-Instances oder **On-Premises-Instances**** aus. Geben Sie in den Feldern **Key (Schlüssel)** und **Value (Wert)** den Schlüssel und den Wert des Instance-Tags ein, der auf Ihre Instance als Teil von [Schritt 4: Stellen Sie eine Instanz bereit](tutorials-github-provision-instance.md) angewendet wurde.

1. **Wählen Sie unter **Bereitstellungskonfiguration** die Option. CodeDeployDefault AllatOnce**.

1. Deaktivieren Sie unter **Load Balancer** die Option **Enable load balancing (Load Balancing aktivieren)**.

1. Erweitern Sie **Advanced (Erweitert)**.

1. Wählen Sie unter **Alarms (Alarme)** die Option **Ignore alarm configuration (Alarmkonfiguration ignorieren)** aus.

1. Wählen Sie **Create deployment group (Bereitstellungsgruppe erstellen)** und fahren Sie mit dem nächsten Schritt fort. 

## Erstellen einer Anwendung und einer Bereitstellungsgruppe (CLI)
<a name="tutorials-github-create-application-cli"></a>

1. Rufen Sie den Befehl **create-application** zum Erstellen einer Anwendung in CodeDeploy mit dem Namen `CodeDeployGitHubDemo-App` auf:

   ```
   aws deploy create-application --application-name CodeDeployGitHubDemo-App
   ```

1. Rufen Sie den Befehl **create-deployment-group** auf, um eine Bereitstellungsgruppe mit dem Namen `CodeDeployGitHubDemo-DepGrp` zu erstellen:
   + Wenn Sie auf einer Amazon EC2 EC2-Instance bereitstellen, *ec2-tag-key* ist der Amazon EC2 EC2-Instance-Tag-Schlüssel, der als Teil von auf Ihre Amazon EC2 EC2-Instance angewendet wurde. [Schritt 4: Stellen Sie eine Instanz bereit](tutorials-github-provision-instance.md)
   + Wenn Sie auf einer Amazon EC2 EC2-Instance bereitstellen, *ec2-tag-value* ist dies der Amazon EC2 EC2-Instance-Tag-Wert, der als Teil von auf Ihre Amazon EC2 EC2-Instance angewendet wurde. [Schritt 4: Stellen Sie eine Instanz bereit](tutorials-github-provision-instance.md)
   + Wenn Sie die Bereitstellung auf einer lokalen Instance durchführen, *on-premises-tag-key* ist dies der lokale Instance-Tag-Schlüssel, der als Teil von auf Ihre lokale Instance angewendet wurde. [Schritt 4: Stellen Sie eine Instanz bereit](tutorials-github-provision-instance.md)
   + Wenn Sie die Bereitstellung auf einer lokalen Instanz durchführen, *on-premises-tag-value* ist dies der Wert des Tags für die lokale Instanz, der als Teil von auf Ihre lokale Instanz angewendet wurde. [Schritt 4: Stellen Sie eine Instanz bereit](tutorials-github-provision-instance.md)
   + *service-role-arn*ist der Dienstrollen-ARN für die Servicerolle, die Sie unter [Eine Servicerolle erstellen für](getting-started-create-service-role.md) erstellt haben CodeDeploy. (Befolgen Sie die Anweisungen unter [Rufen Sie die Servicerolle ARN (CLI) ab](getting-started-create-service-role.md#getting-started-get-service-role-cli), um den ARN der erforderlichen Service-Rolle zu ermitteln.)

   ```
   aws deploy create-deployment-group --application-name CodeDeployGitHubDemo-App --ec2-tag-filters Key=ec2-tag-key,Type=KEY_AND_VALUE,Value=ec2-tag-value --on-premises-tag-filters Key=on-premises-tag-key,Type=KEY_AND_VALUE,Value=on-premises-tag-value --deployment-group-name CodeDeployGitHubDemo-DepGrp --service-role-arn service-role-arn
   ```
**Anmerkung**  
Der [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)Befehl bietet Unterstützung für die Erstellung von Triggern, die zum Senden von Amazon SNS SNS-Benachrichtigungen an Themenabonnenten über bestimmte Ereignisse in Bereitstellungen und Instances führen. Der Befehl unterstützt auch Optionen für das automatische Rollback von Bereitstellungen und die Einrichtung von Alarmen, um Bereitstellungen zu beenden, wenn die Überwachungsschwellenwerte in CloudWatch Amazon-Alarmen erreicht werden. Befehle für diese Aktionen sind in diesem Tutorial nicht enthalten.

# Schritt 6: Stellen Sie die Anwendung auf der Instanz bereit
<a name="tutorials-github-deploy-application"></a>

In diesem Schritt verwenden Sie die CodeDeploy Konsole oder die, AWS CLI um die Beispielrevision aus Ihrem GitHub Repository auf Ihrer Instanz bereitzustellen. 



## Mit der Konsole stellen Sie die Revision wie folgt bereit:
<a name="tutorials-github-deploy-application-console"></a>

1. Klicken Sie auf der Seite **Deployment group details (Details der Bereitstellungsgruppe)** auf **Create deployment (Bereitstellung erstellen)**.

1. Wählen Sie unter **Deployment group (Bereitstellungsgruppe)** die Option **`CodeDeployGitHubDemo-DepGrp`** aus.

1. Wählen Sie **unter Revisionstyp** die Option **GitHub**.

1. Führen **Sie unter GitHub Verbinden mit** einen der folgenden Schritte aus:
   + Um eine Verbindung für CodeDeploy Anwendungen mit einem GitHub Konto herzustellen, melden Sie sich auf einer separaten Registerkarte GitHub im Webbrowser ab. Geben Sie **GitHub unter Konto** einen Namen ein, um diese Verbindung zu identifizieren, und wählen Sie dann **Connect GitHub**. Auf der Webseite werden Sie aufgefordert, die Interaktion mit GitHub der genannten Anwendung CodeDeploy zu autorisieren. `CodeDeployGitHubDemo-App` Fahren Sie fort mit Schritt 5.
   + Um eine Verbindung zu verwenden, die Sie bereits erstellt haben, wählen Sie **GitHubunter Konto** ihren Namen und dann **Connect** aus GitHub. Fahren Sie fort mit Schritt 7.
   + Um eine Verbindung zu einem anderen GitHub Konto herzustellen, melden Sie sich GitHub in einem separaten Webbrowser-Tab ab. Wählen **Sie Connect einem anderen GitHub Konto** verbinden und dann **Connect GitHub**. Fahren Sie fort mit Schritt 5.

1. Folgen Sie den Anweisungen auf der **Anmeldeseite**, um sich mit Ihrem GitHub Konto anzumelden.

1. Wählen Sie auf der Seite **Authorize application** die Option **Authorize application**. 

1. Geben Sie auf der Seite **Einrichtung CodeDeploy erstellen** im Feld **Repository-Name** den GitHub Benutzernamen ein, mit dem Sie sich angemeldet haben, gefolgt von einem Schrägstrich (`/`), gefolgt von dem Namen des Repositorys, in das Sie Ihre Anwendungsrevision übertragen haben (z. B.***my-github-user-name*/CodeDeployGitHubDemo**).

   Falls Sie sich nicht sicher sind, welchen Wert Sie eingeben sollen, oder ein anderes Repository angeben möchten:

   1. Rufen Sie in einem separaten Webbrowser-Tab Ihr [GitHub Dashboard](https://github.com/dashboard) auf.

   1. Platzieren Sie unter **Your repositories** den Mauszeiger auf dem Namen des Ziel-Repositorys. Es erscheint ein Tooltip mit dem Namen des GitHub Benutzers oder der Organisation, gefolgt von einem Schrägstrich (`/`), gefolgt vom Namen des Repositorys. Geben Sie diesen Wert in **Repository name (Repository-Name)** ein.
**Anmerkung**  
Wenn der Name des Ziel-Repositorys nicht in **Ihren Repositorys** angezeigt wird, verwenden Sie das ** GitHubSuchfeld**, um das Ziel-Repository und den GitHub Benutzer- oder Organisationsnamen zu suchen.

1. Geben Sie in das Feld **Commit-ID** die ID des Commits ein, der mit der Übertragung der Revision Ihrer Anwendung verknüpft ist. GitHub

   Falls Sie sich nicht sicher sind, welchen Wert Sie eingeben müssen:

   1. Rufen Sie in einem separaten Webbrowser-Tab Ihr [GitHub Dashboard](https://github.com/dashboard) auf.

   1. Wählen Sie unter **Your repositories (Ihre Repositorys)** **CodeDeployGitHubDemo** aus.

   1. Suchen Sie in der Liste der Commits nach der Commit-ID, die dem Push Ihrer Anwendungsrevision zugeordnet ist, und kopieren Sie sie nach GitHub. Diese ID ist in der Regel 40 Zeichen lang und besteht aus Buchstaben und Zahlen. (Verwenden Sie nicht die kürzere Version der Commit-ID. Sie besteht in der Regel aus den ersten zehn Zeichen der längeren Version.)

   1. Fügen Sie die Commit-ID in das Feld **Commit ID** ein.

1. Wählen Sie **Deploy**, und fahren Sie mit dem nächsten Schritt fort. 

## Mit der CLI stellen Sie die Revision wie folgt bereit:
<a name="tutorials-github-deploy-application-cli"></a>

Bevor Sie AWS CLI Befehle aufrufen können, mit denen Sie interagieren GitHub (z. B. den **create-deployment** Befehl, den Sie als Nächstes aufrufen), müssen Sie die CodeDeploy Erlaubnis erteilen, Ihr GitHub Benutzerkonto GitHub für die Interaktion mit der `CodeDeployGitHubDemo-App` Anwendung zu verwenden. Das können Sie derzeit nur über die CodeDeploy -Konsole tun.

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

   

1. Wählen Sie **CodeDeployGitHubDemo-App**.

1. Klicken Sie auf der Registerkarte **Deployments (Bereitstellungen)** auf **Create deployment (Bereitstellung erstellen)**.
**Anmerkung**  
Sie erstellen keine neue Bereitstellung. Dies ist derzeit die einzige Möglichkeit, die CodeDeploy Erlaubnis zu erteilen, GitHub im Namen Ihres GitHub Benutzerkontos mit Ihnen zu interagieren.

1. Wählen Sie in **der Bereitstellungsgruppe** die Option **CodeDeployGitHubDemo-** ausDepGrp.

1. Wählen Sie unter **Revisionstyp** die Option aus **GitHub**.

1. Führen **Sie unter GitHub Verbinden mit** einen der folgenden Schritte aus:
   + Um eine Verbindung für CodeDeploy Anwendungen mit einem GitHub Konto herzustellen, melden Sie sich auf einer separaten Registerkarte GitHub im Webbrowser ab. Geben Sie **GitHub unter Konto** einen Namen ein, um diese Verbindung zu identifizieren, und wählen Sie dann **Connect** aus GitHub. Auf der Webseite werden Sie aufgefordert, die Interaktion mit GitHub der genannten Anwendung CodeDeploy zu autorisieren. `CodeDeployGitHubDemo-App` Fahren Sie fort mit Schritt 8.
   + Um eine Verbindung zu verwenden, die Sie bereits erstellt haben, wählen Sie **GitHubunter Konto** ihren Namen und dann **Connect** aus GitHub. Fahren Sie fort mit Schritt 10.
   + Um eine Verbindung zu einem anderen GitHub Konto herzustellen, melden Sie sich GitHub in einem separaten Webbrowser-Tab ab. Wählen **Sie Connect einem anderen GitHub Konto** verbinden und dann **Connect GitHub**. Fahren Sie fort mit Schritt 8.

1. Folgen Sie den Anweisungen auf der **Anmeldeseite**, um sich mit Ihrem GitHub Benutzernamen oder Ihrer E-Mail-Adresse und Ihrem Passwort anzumelden.

1. Wählen Sie auf der Seite **Authorize application** die Option **Authorize application**. 

1. Wählen Sie auf der Seite **Bereitstellung CodeDeploy erstellen** die Option **Abbrechen** aus.

1. Rufen Sie den **create-deployment** Befehl auf, um die Revision aus Ihrem GitHub Repository für die Instance bereitzustellen. Dabei gilt:
   + *repository*ist Ihr GitHub Kontoname, gefolgt von einem Schrägstrich (`/`), gefolgt vom Namen Ihres Repositorys (`CodeDeployGitHubDemo`), zum Beispiel. `MyGitHubUserName/CodeDeployGitHubDemo`

     Falls Sie sich nicht sicher sind, welchen Wert Sie verwenden sollen, oder ein anderes Repository angeben möchten:

     1. [Gehen Sie in einem separaten Webbrowser-Tab zu Ihrem GitHub Dashboard.](https://github.com/dashboard)

     1. Platzieren Sie unter **Your repositories** den Mauszeiger auf dem Namen des Ziel-Repositorys. Es erscheint ein Tooltip mit dem Namen des GitHub Benutzers oder der Organisation, gefolgt von einem Schrägstrich (`/`), gefolgt vom Namen des Repositorys. Das ist der Wert, den Sie verwenden müssen.
**Anmerkung**  
Wenn der Name des Ziel-Repositorys nicht in **Ihren Repositorys** erscheint, verwenden Sie das ** GitHubSuchfeld**, um das Ziel-Repository und den entsprechenden GitHub Benutzer- oder Organisationsnamen zu finden.
   + *commit-id*ist der Commit, der mit der Version der Anwendungsrevision verknüpft ist, die Sie in Ihr Repository übertragen haben (z. B.`f835159a...528eb76f`). 

     Falls Sie sich nicht sicher sind, welchen Wert Sie verwenden müssen:

     1. Rufen Sie in einem separaten Webbrowser-Tab Ihr [GitHub Dashboard](https://github.com/dashboard) auf.

     1. Wählen Sie unter **Your repositories (Ihre Repositorys)** **CodeDeployGitHubDemo** aus.

     1. Suchen Sie in der Liste der Commits nach der Commit-ID, die dem Push Ihrer Anwendungsrevision zugeordnet GitHub ist. Diese ID ist in der Regel 40 Zeichen lang und besteht aus Buchstaben und Zahlen. (Verwenden Sie nicht die kürzere Version der Commit-ID. Sie besteht in der Regel aus den ersten zehn Zeichen der längeren Version.) Verwenden Sie diesen Wert.

   Wenn Sie auf einem lokalen Linux-, macOS- oder Unix-Computer arbeiten:

   ```
   aws deploy create-deployment \
     --application-name CodeDeployGitHubDemo-App \
     --deployment-config-name CodeDeployDefault.OneAtATime \
     --deployment-group-name CodeDeployGitHubDemo-DepGrp \
     --description "My GitHub deployment demo" \
     --github-location repository=repository,commitId=commit-id
   ```

   Wenn Sie auf einem lokalen Computer mit Windows arbeiten:

   ```
   aws deploy create-deployment --application-name CodeDeployGitHubDemo-App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name CodeDeployGitHubDemo-DepGrp --description "My GitHub deployment demo" --github-location repository=repository,commitId=commit-id
   ```

# Schritt 7: Überwachen und verifizieren Sie die Bereitstellung
<a name="tutorials-github-verify"></a>

In diesem Schritt verwenden Sie die CodeDeploy Konsole oder die, AWS CLI um den Erfolg der Bereitstellung zu überprüfen. Außerdem öffnen Sie die in der erstellten oder konfigurierten Instance bereitgestellte Webseite in Ihrem Webbrowser.

**Anmerkung**  
Wenn Sie die Bereitstellung auf einer Ubuntu Server-Instanz durchführen, verwenden Sie Ihre eigene Teststrategie, um festzustellen, ob die bereitgestellte Version auf der Instanz erwartungsgemäß funktioniert, und fahren Sie dann mit dem nächsten Schritt fort.

**Mit der Konsole überwachen und überprüfen Sie die Bereitstellung wie folgt:**

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Bereitstellungen** aus.

   

1. **Suchen Sie in der Liste der Bereitstellungen nach der Zeile mit dem **Anwendungswert CodeDeployGitHubDemo** **-App und dem **Bereitstellungsgruppenwert** -**. CodeDeployGitHubDemo DepGrp** Wenn weder **Succeeded** noch **Failed** in der Spalte **Status** angezeigt werden, betätigen Sie mehrmals die Schaltfläche **Refresh**.

1. Wenn **Failed** in der Spalte **Status** angezeigt wird, befolgen Sie die Anweisungen in [Instanzdetails anzeigen (Konsole)](instances-view-details.md#instances-view-details-console), um die Probleme mit der Bereitstellung zu beheben.

1. Wenn **Succeeded** in der Spalte **Status** angezeigt wird, können Sie die Bereitstellung in Ihrem Webbrowser überprüfen. Unsere Beispielrevision stellt eine einzelne Webseite in der Instance bereit. Wenn Sie die Bereitstellung auf einer Amazon EC2 EC2-Instance durchführen, gehen Sie in Ihrem Webbrowser zu `http://public-dns` für die Instance (z. B.`http://ec2-01-234-567-890.compute-1.amazonaws.com`).

1. Wenn Sie die Webseite sehen können, sind keine Fehler aufgetreten. Nachdem Sie das Deployment einer Version von erfolgreich verwendet AWS CodeDeploy haben GitHub, können Sie mit dem nächsten Schritt fortfahren[Schritt 8: Bereinigen](tutorials-github-clean-up.md).

**Mit der CLI überwachen und überprüfen Sie die Bereitstellung wie folgt:**

1. Rufen Sie den Befehl **list-deployments** auf, um die Bereitstellungs-ID für die Anwendung `CodeDeployGitHubDemo-App` und die Bereitstellungsgruppe `CodeDeployGitHubDemo-DepGrp` abzurufen:

   ```
   aws deploy list-deployments --application-name CodeDeployGitHubDemo-App --deployment-group-name CodeDeployGitHubDemo-DepGrp --query "deployments" --output text
   ```

1. Rufen Sie den Befehl **get-deployment** mit der Bereitstellungs-ID aus der Ausgabe des Befehls **list-deployments** auf:

   ```
   aws deploy get-deployment --deployment-id deployment-id --query "deploymentInfo.[status, creator]" --output text
   ```

1. Wenn **Failed** zurückgegeben wird: Befolgen Sie die Anweisungen unter [Instanzdetails anzeigen (Konsole)](instances-view-details.md#instances-view-details-console), um die Probleme mit der Bereitstellung zu beheben.

1. Wenn **Succeeded** zurückgegeben wird: Überprüfen Sie die Bereitstellung in Ihrem Webbrowser. Unsere Beispielrevision ist eine einzelne Webseite, die in der Instance bereitgestellt wird. Wenn Sie die Bereitstellung auf einer Amazon EC2 EC2-Instance durchführen, können Sie diese Seite in Ihrem Webbrowser aufrufen, indem Sie zu `http://public-dns` der Amazon EC2 EC2-Instance gehen (z. B.`http://ec2-01-234-567-890.compute-1.amazonaws.com`).

1. Wenn Sie die Webseite sehen können, sind keine Fehler aufgetreten. Sie haben die Bereitstellung aus Ihrem GitHub Repository erfolgreich verwendet AWS CodeDeploy .

# Schritt 8: Bereinigen
<a name="tutorials-github-clean-up"></a>

Um weitere Gebühren für Ressourcen zu vermeiden, die Sie in diesem Tutorial verwendet haben, müssen Sie die Amazon EC2 EC2-Instance und die zugehörigen Ressourcen beenden. Optional können Sie auch die zu diesem Tutorial gehörenden CodeDeploy-Bereitstellungskomponentendatensätze löschen. Wenn Sie ein GitHub Repository nur für dieses Tutorial verwendet haben, können Sie es jetzt auch löschen.

## Um einen CloudFormation Stack zu löschen (wenn Sie die CloudFormation Vorlage zum Erstellen einer Amazon EC2 EC2-Instance verwendet haben)
<a name="tutorials-github-clean-up-cloudformation-template"></a>

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Wählen Sie in der Spalte **Stacks** den Stack aus, der mit `CodeDeploySampleStack` beginnt.

1. Wählen Sie **Löschen** aus.

1. Wählen Sie bei Aufforderung **Delete stack (Stack löschen)** aus. Die Amazon EC2 EC2-Instance und das zugehörige IAM-Instance-Profil und die Service-Rolle werden gelöscht.

## Heben Sie wie folgt manuell die Registrierung einer lokalen Instance auf und bereinigen Sie sie (falls Sie eine lokale Instance bereitgestellt haben):
<a name="tutorials-github-clean-up-on-premises-instance"></a>

1. Verwenden Sie den AWS CLI , um den Befehl [deregister](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html) für die lokale Instance aufzurufen, die hier dargestellt wird durch *your-instance-name* und die zugehörige Region durch: *your-region*

   ```
   aws deploy deregister --instance-name your-instance-name --no-delete-iam-user --region your-region
   ```

1. [Rufen Sie von der lokalen Instanz aus den Befehl uninstall auf:](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html)

   ```
   aws deploy uninstall
   ```

## Um eine Amazon EC2 EC2-Instance manuell zu beenden (wenn Sie eine Amazon EC2 EC2-Instance manuell gestartet haben)
<a name="tutorials-github-clean-up-ec2-instance"></a>

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie im Navigationsbereich unter **Instances** die Option **Instances**.

1. Wählen Sie das Kästchen neben der Amazon EC2 EC2-Instance aus, die Sie beenden möchten. Zeigen Sie im Menü **Actions** auf **Instance State**, und wählen Sie dann **Terminate**.

1. Wählen Sie bei Aufforderung **Yes, Terminate**. 

## Um die Datensätze der CodeDeploy Bereitstellungskomponenten zu löschen
<a name="tutorials-github-clean-up-codedeploy-records"></a>

1. Melden Sie sich bei [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy) an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole.
**Anmerkung**  
Melden Sie sich mit demselben Benutzer an, den Sie eingerichtet haben. [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md)

1. Erweitern Sie im Navigationsbereich die Option **Bereitstellen** und wählen Sie dann **Anwendungen** aus.

   

1. Wählen Sie **CodeDeployGitHubDemo-App**.

1. Klicken Sie auf **Delete Application (Anwendung löschen)**.

1. Geben Sie bei der Aufforderung **Delete** ein und klicken Sie dann auf **Delete (Löschen)**. 

## Um dein GitHub Repository zu löschen
<a name="tutorials-github-clean-up-github-repository"></a>

Weitere Informationen finden [Sie in der [GitHub Hilfe](https://help.github.com) unter Löschen eines Repositorys](https://help.github.com/articles/deleting-a-repository/).

# Tutorial: Bereitstellen einer Anwendung in Amazon ECS
<a name="tutorial-ecs-deployment"></a>

 In diesem Tutorial erfahren Sie, wie Sie eine Anwendung in Amazon ECS mithilfe von bereitstellen CodeDeploy. Sie beginnen mit einer Anwendung, die Sie bereits erstellt und in Amazon ECS bereitgestellt haben. Der erste Schritt besteht darin, Ihre Anwendung zu aktualisieren, indem Sie ihre Aufgabendefinitionsdatei mit einem neuen Tag ändern. Als Nächstes verwenden Sie, CodeDeploy um das Update bereitzustellen. CodeDeploy Installiert Ihr Update während der Bereitstellung in einem neuen Ersatz-Taskset. Dann verlagert es den Produktionsdatenverkehr von der ursprünglichen Version Ihrer Amazon ECS-Anwendung, die sich in ihrem ursprünglichen Task-Set befindet, auf die aktualisierte Version im Ersatz-Task-Set.

 CodeDeploy Verwendet während einer Amazon ECS-Bereitstellung einen Load Balancer, der für zwei Zielgruppen und einen Production-Traffic-Listener konfiguriert ist. Das folgende Diagramm zeigt, wie der Load Balancer, der Produktions-Listener, die Zielgruppen und Ihre Amazon ECS-Anwendung zusammenhängen, bevor die Bereitstellung beginnt. In diesem Tutorial wird ein Application Load Balancer verwendet. Sie können auch einen Network Load Balancer verwenden. 

![\[Der Application Load Balancer oder Network Load Balancer, ein Produktions-Listener, zwei Zielgruppen, ein Task-Set und ein Amazon ECS-Service.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-with-no-test-listener-step-1.png)


 Nach einer erfolgreichen Bereitstellung leitet der Produktionsdatenverkehr-Listener Datenverkehr an Ihren neuen Ersatzaufgabensatz weiter und der ursprüngliche Aufgabensatz wird beendet. Das folgende Diagramm zeigt, wie Ihre Ressourcen nach einer erfolgreichen Bereitstellung miteinander verbunden sind. Weitere Informationen finden Sie unter [Was passiert während einer Amazon ECS-Bereitstellung](deployment-steps-ecs.md#deployment-steps-what-happens). 

![\[Der Application Load Balancer oder Network Load Balancer, ein Produktions-Listener, zwei Zielgruppen und ein Ersatz-Taskset.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-with-no-test-listener-step-5.png)


Informationen zur Verwendung von AWS CLI zum Bereitstellen einer Anwendung in Amazon ECS finden Sie unter [Tutorial: Einen Service mithilfe einer blue/green Bereitstellung erstellen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-blue-green.html). Informationen zur Erkennung und automatischen Bereitstellung von Änderungen an einem Amazon ECS-Service finden Sie unter [Tutorial: Eine Pipeline mit einer Amazon ECR-Quelle und ECS-to-CodeDeploy Bereitstellung erstellen](https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-ecs-ecr-codedeploy.html). CodePipeline CodeDeploy 

Nachdem Sie dieses Tutorial abgeschlossen haben, können Sie die von Ihnen erstellte CodeDeploy Anwendung und Bereitstellungsgruppe verwenden, um einen Validierungstest für die Bereitstellung hinzuzufügen. [Tutorial: Bereitstellen eines Amazon ECS-Service mit einem Validierungstest](tutorial-ecs-deployment-with-hooks.md) 

**Topics**
+ [Voraussetzungen](tutorial-ecs-prereqs.md)
+ [Schritt 1: Aktualisieren Sie Ihre Amazon ECS-Anwendung](tutorial-ecs-update-the-ecs-application.md)
+ [Schritt 2: Erstellen Sie die Datei AppSpec](tutorial-ecs-create-appspec-file.md)
+ [Schritt 3: Verwenden Sie die CodeDeploy Konsole, um Ihre Anwendung bereitzustellen](tutorial-ecs-deployment-deploy.md)
+ [Schritt 4: Bereinigen](tutorial-ecs-clean-up.md)

# Voraussetzungen
<a name="tutorial-ecs-prereqs"></a>

Um dieses Tutorial abzuschließen, müssen Sie zunächst:
+  Die Schritte 2 und 3 in [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md) ausführen. 
+  Erstellen Sie einen Application Load Balancer, der mit zwei Zielgruppen und einem Listener konfiguriert ist. Weitere Informationen zum Erstellen eines Load Balancers mithilfe der Konsole finden Sie unter [Einen Load Balancer, Zielgruppen und Listener für CodeDeploy Amazon ECS-Bereitstellungen einrichten](deployment-groups-create-load-balancer-for-ecs.md). Informationen zum Erstellen eines Load Balancers mit dem AWS CLI finden Sie unter [Schritt 1: Einen Application Load Balancer erstellen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-blue-green.html#create-blue-green-loadbalancer) im *Amazon Elastic Container Service-Benutzerhandbuch*. Wenn Sie Ihren Load Balancer erstellen, notieren Sie sich Folgendes für dieses Tutorial: 
  +  Den Namen Ihres Load Balancer. 
  +  Die Namen Ihrer Zielgruppen. 
  +  Den Port, der vom Listener Ihres Load Balancers verwendet wird. 
+  Erstellen Sie einen Amazon ECS-Cluster und -Service. Weitere Informationen finden Sie in den Schritten 2, 3 und 4 im [Tutorial: Einen Service mithilfe einer blue/green Bereitstellung erstellen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-blue-green.html) im *Amazon Elastic Container Service-Benutzerhandbuch*. Notieren Sie sich Folgendes für dieses Tutorial: 
  +  Der Name Ihres Amazon ECS-Clusters. 
  +  Der ARN der Aufgabendefinition, die von Ihrem Amazon ECS-Service verwendet wird. 
  +  Der Name des Containers, der von Ihrem Amazon ECS-Service verwendet wird. 
+  Erstellen Sie einen Amazon S3 S3-Bucket für Ihre AppSpec Datei. 

# Schritt 1: Aktualisieren Sie Ihre Amazon ECS-Anwendung
<a name="tutorial-ecs-update-the-ecs-application"></a>

 In diesem Abschnitt aktualisieren Sie Ihre Amazon ECS-Anwendung mit einer neuen Version ihrer Aufgabendefinition. Die aktualisierte Revision fügt ein neues Schlüssel- und Tag-Paar hinzu. In [Schritt 3: Verwenden Sie die CodeDeploy Konsole, um Ihre Anwendung bereitzustellen](tutorial-ecs-deployment-deploy.md) stellen Sie die aktualisierte Version Ihrer Amazon ECS-Anwendung bereit. 

**So aktualisieren Sie Ihre Aufgabendefinition**

1. Öffnen Sie die Konsole auf [https://console.aws.amazon.com/ecs/Version](https://console.aws.amazon.com/ecs/v2) 2.

1.  Wählen Sie im Navigationsbereich **Task Definitions** aus. 

1. Wählen Sie die Aufgabendefinition aus, die von Ihrem Amazon ECS-Service verwendet wird.

1. Markieren Sie die Aufgabendefinitionsversion und wählen Sie dann **Neue Version erstellen**, **Neue Version erstellen**.

1.  Nehmen Sie für dieses Tutorial eine kleine Aktualisierung der Aufgabendefinition vor, indem Sie ein Tag hinzufügen. Erstellen Sie unten auf der Seite unter **Tags** ein neues Tag, indem Sie ein neues Schlüssel-Wert-Paar eingeben. 

1.  Wählen Sie **Erstellen** aus. 

   Die Revisionsnummer Ihrer Aufgabendefinition wird um eins erhöht. 

1.  Wählen Sie den Tab **JSON**. Notieren Sie sich Folgendes, da Sie diese Informationen im nächsten Schritt benötigen. 
   +  Den Wert für `taskDefinitionArn`. Das Format ist `arn:aws:ecs:aws-region:account-id:task-definition/task-definition-family:task-definition-revision`. Dies ist der ARN Ihrer aktualisierten Aufgabendefinition. 
   +  Den Wert für `name` im `containerDefinitions`-Element. Dies ist der Name Ihres Containers. 
   +  Den Wert für `containerPort` im `portMappings`-Element. Dies ist der Port für Ihren Container. 

# Schritt 2: Erstellen Sie die Datei AppSpec
<a name="tutorial-ecs-create-appspec-file"></a>

 In diesem Abschnitt erstellen Sie Ihre AppSpec Datei und laden sie in den Amazon S3 S3-Bucket hoch, den Sie in dem [Voraussetzungen](tutorial-ecs-prereqs.md) Abschnitt erstellt haben. Die AppSpec Datei für eine Amazon ECS-Bereitstellung spezifiziert Ihre Aufgabendefinition, Ihren Container-Namen und Ihren Container-Port. Weitere Informationen erhalten Sie unter [AppSpec Dateibeispiel für eine Amazon ECS-Bereitstellung](reference-appspec-file-example.md#appspec-file-example-ecs) und [AppSpec Abschnitt „Ressourcen“ für Amazon ECS-Bereitstellungen](reference-appspec-file-structure-resources.md#reference-appspec-file-structure-resources-ecs). 

**Um Ihre AppSpec Datei zu erstellen**

1.  Wenn Sie Ihre AppSpec Datei mit YAML erstellen möchten, erstellen Sie eine Datei mit dem Namen`appspec.yml`. Wenn Sie Ihre AppSpec Datei mit JSON erstellen möchten, erstellen Sie eine Datei mit dem Namen`appspec.json`. 

1.  Wählen Sie die entsprechende Registerkarte, je nachdem, ob Sie YAML oder JSON für Ihre AppSpec Datei verwenden, und kopieren Sie deren Inhalt in die AppSpec Datei, die Sie gerade erstellt haben. Verwenden Sie für die `TaskDefinition`-Eigenschaft den Aufgabendefinitions-ARN, den Sie im [Schritt 1: Aktualisieren Sie Ihre Amazon ECS-Anwendung](tutorial-ecs-update-the-ecs-application.md)-Abschnitt notiert haben. 

------
#### [ JSON AppSpec ]

   ```
   {
     "version": 0.0,
     "Resources": [
       {
         "TargetService": {
           "Type": "AWS::ECS::Service",
           "Properties": {
             "TaskDefinition": "arn:aws:ecs:aws-region-id:aws-account-id:task-definition/ecs-demo-task-definition:revision-number",
             "LoadBalancerInfo": {
               "ContainerName": "your-container-name",
               "ContainerPort": your-container-port
             }
           }
         }
       }
     ]
   }
   ```

------
#### [ YAML AppSpec ]

   ```
   version: 0.0
   Resources:
     - TargetService:
         Type: AWS::ECS::Service
         Properties:
           TaskDefinition: "arn:aws:ecs:aws-region-id:aws-account-id:task-definition/ecs-demo-task-definition:revision-number"
           LoadBalancerInfo:
             ContainerName: "your-container-name"
             ContainerPort: your-container-port
   ```

------
**Anmerkung**  
 Ihr neuer Aufgabensatz erbt das Subnetz, die Sicherheitsgruppe, die Plattformversion und die zugewiesenen öffentlichen IP-Werte von Ihrem ursprünglichen Aufgabensatz. Sie können diese Werte für Ihren Ersatz-Tasksatz überschreiben, indem Sie ihre optionalen Eigenschaften in Ihrer AppSpec Datei festlegen. Weitere Informationen erhalten Sie unter [AppSpec Abschnitt „Ressourcen“ für Amazon ECS-Bereitstellungen](reference-appspec-file-structure-resources.md#reference-appspec-file-structure-resources-ecs) und [AppSpec Dateibeispiel für eine Amazon ECS-Bereitstellung](reference-appspec-file-example.md#appspec-file-example-ecs). 

1.  Laden Sie Ihre AppSpec Datei in den S3-Bucket hoch, den Sie als Voraussetzung für dieses Tutorial erstellt haben. 

# Schritt 3: Verwenden Sie die CodeDeploy Konsole, um Ihre Anwendung bereitzustellen
<a name="tutorial-ecs-deployment-deploy"></a>

 In diesem Abschnitt erstellen Sie eine CodeDeploy Anwendungs- und Bereitstellungsgruppe, um Ihre aktualisierte Anwendung in Amazon ECS bereitzustellen. CodeDeploy Verschiebt während der Bereitstellung den Produktionsdatenverkehr für Ihre Anwendung auf die neue Version in einem neuen Ersatzaufgabensatz. Um diesen Schritt abzuschließen, benötigen Sie die folgenden Elemente: 
+  Ihr Amazon ECS-Clustername. 
+  Ihr Amazon ECS-Servicename. 
+  Ihr Application Load Balancer Balancer-Name. 
+  Ihren Produktions-Listener-Port. 
+  Ihre Zielgruppennamen. 
+  Den Namen des S3-Buckets, den Sie erstellt haben. 

**Um eine Anwendung zu erstellen CodeDeploy**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).

1. Wählen Sie **Create application** aus.

1. Geben Sie unter **Application name (Anwendungsname)** **ecs-demo-codedeploy-app** ein.

1. Wählen Sie unter **Compute Platform (Datenverarbeitungsplattform)** die Option **Amazon ECS** aus.

1. Wählen Sie **Create application** aus.

**Um eine CodeDeploy Bereitstellungsgruppe zu erstellen**

1. Wählen Sie auf der Registerkarte **Deployment groups (Bereitstellungsgruppen)** Ihrer Anwendungsseite **Create deployment group (Bereitstellungsgruppe erstellen)** aus.

1. Geben Sie unter **Deployment group name (Name der Bereitstellungsgruppe)** **ecs-demo-dg** ein.

1. Wählen Sie unter **Servicerolle** eine Servicerolle aus, die CodeDeploy Zugriff auf Amazon ECS gewährt. Weitere Informationen finden Sie unter [Identitäts- und Zugriffsmanagement für AWS CodeDeploy](security-iam.md).

1. Wählen Sie in der **Umgebungskonfiguration** Ihren Amazon ECS-Clusternamen und Servicenamen aus.

1. Wählen Sie **unter Load Balancers** den Namen des Load Balancers aus, der den Datenverkehr an Ihren Amazon ECS-Service weiterleitet.

1. Wählen Sie **unter Production Listener Port** den Port und das Protokoll für den Listener aus, der Produktionstransport für Ihren Amazon ECS-Service bereitstellt (z. B. **HTTP:** 80). Dieses Tutorial enthält keinen optionalen Test-Listener. Wählen Sie daher keinen Port aus **Test listener port (Test-Listener-Port)** aus. 

1. Wählen Sie unter **Target group 1 name (Name der Zielgruppe 1)** und **Target group 2 name (Name der Zielgruppe 2)** zwei verschiedene Zielgruppen aus, um den Datenverkehr während der Bereitstellung weiterzuleiten. Stellen Sie sicher, dass es sich hierbei um die Zielgruppen handelt, die Sie für Ihren Load Balancer erstellt haben. Es spielt keine Rolle, welche für Zielgruppe 1 und welche für Zielgruppe 2 verwendet wird.

1. Wählen Sie **Reroute traffic immediately (Datenverkehr sofort umleiten)** aus.

1. Wählen Sie für **Original revision termination (Beendigung der ursprünglichen Revision)** 0 Tage, 0 Stunden und 5 Minuten aus. Auf diese Weise können Sie Ihre Bereitstellung schneller abschließen, als wenn Sie die Standardeinstellung (1 Stunde) verwenden.  
![\[Der Bereich mit der Umgebungskonfiguration der Konsole. CodeDeploy\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/ecs-demo-create-acd-dg.png)

1. Wählen Si **Create deployment group (Bereitstellungsgruppe erstellen)**.

**So stellen Sie Ihre Amazon ECS-Anwendung bereit**

1. Wählen Sie auf der Konsolenseite Ihrer Bereitstellungsgruppe **Create deployment (Bereitstellung erstellen)** aus.

1.  Wählen Sie als **Bereitstellungsgruppe** die Option **ecs-demo-dg**. 

1.  Wählen Sie unter **Revision type (Revisionstyp)** die Option **My application is stored in Amazon S3 (Meine Anwendung ist in Amazon S3 gespeichert)** aus. Geben Sie unter **Revision location (Speicherort der Revision)** den Namen Ihres S3-Buckets ein. 

1.  Wählen Sie für **Revision file type (Revisionsdateityp)** die Option **.json** oder **.yaml** nach Bedarf aus. 

1.  (Optional) Geben Sie im Feld **Deployment description (Bereitstellungsbeschreibung)** eine Beschreibung für Ihre Bereitstellung ein. 

1. Wählen Sie **Create deployment**.

1.  Unter **Deployment status (Bereitstellungsstatus)** können Sie Ihre Bereitstellung überwachen. Nachdem der gesamte Produktionsdatenverkehr an den Ersatz-Tasksatz weitergeleitet wurde und die Wartezeit von fünf Minuten abläuft, können Sie die Option Ursprünglichen Tasksatz **beenden auswählen, um den ursprünglichen Tasksatz** sofort zu beenden. Wenn Sie **Terminate original task set (Ursprünglichen Aufgabensatz beenden)** nicht auswählen, wird der ursprüngliche Aufgabensatz nach der von Ihnen angegebenen fünfminütigen Wartezeit beendet.  
![\[Der Abschnitt mit dem Bereitstellungsstatus der CodeDeploy Konsole.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/ecs-tutorial-deployment-status-without-test-listener.png)

# Schritt 4: Bereinigen
<a name="tutorial-ecs-clean-up"></a>

 Das nächste Tutorial, [Tutorial: Bereitstellen eines Amazon ECS-Service mit einem Validierungstest](tutorial-ecs-deployment-with-hooks.md), baut auf diesem Tutorial auf und verwendet die von Ihnen erstellte CodeDeploy -Anwendung und -Bereitstellungsgruppe. Wenn Sie die Schritte in diesem Tutorial ausführen möchten, überspringen Sie diesen Schritt und löschen Sie nicht die Ressourcen, die Sie erstellt haben. 

**Anmerkung**  
 Für Ihr AWS Konto fallen keine Gebühren für die von Ihnen erstellten CodeDeploy Ressourcen an. 

Bei den Ressourcennamen in diesen Schritten handelt es sich um die in diesem Tutorial vorgeschlagenen Namen (z. B. **ecs-demo-codedeploy-app** für den Namen Ihrer CodeDeploy Anwendung). Wenn Sie andere Namen verwendet haben, stellen Sie sicher, dass Sie diese während der Bereinigung verwenden. 

1. Verwenden Sie den [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)Befehl, um die CodeDeploy Bereitstellungsgruppe zu löschen.

   ```
   aws deploy delete-deployment-group --application-name ecs-demo-codedeploy-app --deployment-group-name ecs-demo-dg --region aws-region-id
   ```

1. Verwenden Sie den Befehl [delete-application, um die Anwendung](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) zu löschen. CodeDeploy 

   ```
   aws deploy delete-application --application-name ecs-demo-codedeploy-app --region aws-region-id
   ```

# Tutorial: Bereitstellen eines Amazon ECS-Service mit einem Validierungstest
<a name="tutorial-ecs-deployment-with-hooks"></a>

 In diesem Tutorial erfahren Sie, wie Sie eine Lambda-Funktion verwenden, um einen Teil der Bereitstellung einer aktualisierten Amazon ECS-Anwendung zu validieren. In diesem Tutorial werden die CodeDeploy Anwendung, die CodeDeploy Bereitstellungsgruppe und die Amazon ECS-Anwendung verwendet, die Sie in verwendet haben[Tutorial: Bereitstellen einer Anwendung in Amazon ECS](tutorial-ecs-deployment.md). Schließen Sie dieses Tutorial ab, bevor Sie mit diesem beginnen.

 Um einen Validierungstest hinzuzufügen, implementieren Sie den Test zunächst in einer Lambda-Funktion. Als Nächstes geben Sie in Ihrer AppSpec Bereitstellungsdatei die Lambda-Funktion für den Lifecycle-Hook an, den Sie testen möchten. Wenn ein Validierungstest fehlschlägt, wird die Bereitstellung gestoppt, zurückgesetzt und als fehlgeschlagen gekennzeichnet. Wenn der Test erfolgreich ist, wird die Bereitstellung mit dem nächsten Bereitstellungslebenszyklus-Ereignis oder -Hook fortgesetzt. 

 CodeDeploy Verwendet während einer Amazon ECS-Bereitstellung mit Validierungstests einen Load Balancer, der für zwei Zielgruppen konfiguriert ist: einen Produktions-Traffic-Listener und einen Test-Traffic-Listener. Das folgende Diagramm zeigt, wie der Load Balancer, die Produktions- und Test-Listener, die Zielgruppen und Ihre Amazon ECS-Anwendung zusammenhängen, bevor die Bereitstellung beginnt. In diesem Tutorial wird ein Application Load Balancer verwendet. Sie können auch einen Network Load Balancer verwenden. 

![\[Die Verbindungen zwischen dem Application Load Balancer oder Network Load Balancer, den Listenern, den Zielgruppen, dem Task-Set und dem Amazon ECS-Service.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-1.png)


 Während einer Amazon ECS-Bereitstellung gibt es fünf Lifecycle-Hooks zum Testen. Dieses Tutorial implementiert einen Test während des dritten Lebenszyklusbereitstellungs-Hooks, `AfterAllowTestTraffic`. Weitere Informationen finden Sie unter [Liste der Lifecycle-Event-Hooks für eine Amazon ECS-Bereitstellung](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs). Nach einer erfolgreichen Bereitstellung leitet der Produktionsdatenverkehr-Listener Datenverkehr an Ihren neuen Aufgabensatz weiter und der ursprüngliche Aufgabensatz wird beendet. Das folgende Diagramm zeigt, wie Ihre Ressourcen nach einer erfolgreichen Bereitstellung miteinander verbunden sind. Weitere Informationen finden Sie unter [Was passiert während einer Amazon ECS-Bereitstellung](deployment-steps-ecs.md#deployment-steps-what-happens). 

![\[Die Verbindungen zwischen dem Application Load Balancer oder Network Load Balancer, den Listenern, Zielgruppen und dem Ersatz-Taskset nach einer Bereitstellung.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-6.png)


**Anmerkung**  
Wenn Sie dieses Tutorial abschließen, kann dies zu Belastungen Ihres Kontos führen. AWS Dazu gehören mögliche Gebühren für CodeDeploy AWS Lambda, und CloudWatch. Weitere Informationen finden Sie unter [AWS CodeDeploy Preise](https://aws.amazon.com/codedeploy/pricing/), [AWS Lambda Preise](https://aws.amazon.com/lambda/pricing/) und [ CloudWatch Amazon-Preise](https://aws.amazon.com/cloudwatch/pricing/).

**Topics**
+ [Voraussetzungen](tutorial-ecs-with-hooks-prereqs.md)
+ [Schritt 1: Erstellen Sie einen Test-Listener](tutorial-ecs-with-hooks-create-second-listener.md)
+ [Schritt 2: Aktualisieren Sie Ihre Amazon ECS-Anwendung](tutorial-ecs-with-hooks-update-the-ecs-application.md)
+ [Schritt 3: Erstellen Sie eine Lifecycle-Hook-Lambda-Funktion](tutorial-ecs-with-hooks-create-hooks.md)
+ [Schritt 4: Aktualisieren Sie Ihre AppSpec Datei](tutorial-ecs-with-hooks-create-appspec-file.md)
+ [Schritt 5: Verwenden Sie die CodeDeploy Konsole, um Ihren Amazon ECS-Service bereitzustellen](tutorial-ecs-with-hooks-deployment.md)
+ [Schritt 6: Zeigen Sie die Ausgabe Ihrer Lambda-Hook-Funktion in Logs an CloudWatch](tutorial-ecs-with-hooks-view-cw-logs.md)
+ [Schritt 7: Bereinigen](tutoria-ecs-with-hooks-clean-up.md)

# Voraussetzungen
<a name="tutorial-ecs-with-hooks-prereqs"></a>

Um dieses Tutorial erfolgreich abzuschließen, müssen Sie zunächst:
+  Die Voraussetzungen unter [Voraussetzungen](tutorial-ecs-prereqs.md) für [Tutorial: Bereitstellen einer Anwendung in Amazon ECS](tutorial-ecs-deployment.md) erfüllen. 
+  Führen Sie die Schritte unter [Tutorial: Bereitstellen einer Anwendung in Amazon ECS](tutorial-ecs-deployment.md) aus. Notieren Sie sich Folgendes: 
  +  Den Namen Ihres Load Balancer. 
  +  Die Namen Ihrer Zielgruppen. 
  +  Den Port, der vom Listener Ihres Load Balancers verwendet wird. 
  +  Den ARN Ihres Load Balancers. Damit erstellen Sie einen neuen Listener. 
  +  Den ARN einer Ihrer Zielgruppen. Damit erstellen Sie einen neuen Listener. 
  +  Die CodeDeploy Anwendung und die Bereitstellungsgruppe, die Sie erstellen. 
  +  Die von Ihnen erstellte AppSpec Datei, die von Ihrer CodeDeploy Bereitstellung verwendet wird. Sie bearbeiten diese Datei in diesem Tutorial. 

# Schritt 1: Erstellen Sie einen Test-Listener
<a name="tutorial-ecs-with-hooks-create-second-listener"></a>

 Eine Amazon ECS-Bereitstellung mit Validierungstests erfordert einen zweiten Listener. Dieser Listener wird verwendet, um Testdatenverkehr für Ihre aktualisierte Amazon ECS-Anwendung in einem Ersatzaufgabensatz bereitzustellen. Ihre Validierungstests werden anhand des Testdatenverkehrs ausgeführt. 

 Der Listener für Ihren Testdatenverkehr kann eine der Zielgruppen verwenden. Verwenden Sie den AWS CLI Befehl [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html), um einen zweiten Listener mit einer Standardregel zu erstellen, die Testdatenverkehr an Port 8080 weiterleitet. Verwenden Sie den ARN Ihres Load Balancers und den ARN einer Ihrer Zielgruppen.

```
aws elbv2 create-listener --load-balancer-arn your-load-balancer-arn \
--protocol HTTP --port 8080 \
--default-actions Type=forward,TargetGroupArn=your-target-group-arn --region your-aws-region
```

# Schritt 2: Aktualisieren Sie Ihre Amazon ECS-Anwendung
<a name="tutorial-ecs-with-hooks-update-the-ecs-application"></a>

 In diesem Abschnitt aktualisieren Sie Ihre Amazon ECS-Anwendung, sodass sie eine neue Version ihrer Aufgabendefinition verwendet. Sie erstellen die neue Revision und fügen ihr eine kleinere Aktualisierung hinzu, indem Sie ein Tag hinzufügen. 

**So aktualisieren Sie Ihre Aufgabendefinition**

1. Öffnen Sie die Amazon ECS Classic-Konsole unter [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

1.  Wählen Sie im Navigationsbereich **Task Definitions** aus. 

1.  Aktivieren Sie das Kontrollkästchen für die Aufgabendefinition, die von Ihrem Amazon ECS-Service verwendet wird.

1.  Wählen Sie **Create new revision (Neue Revision erstellen)** aus. 

1.  Nehmen Sie eine kleine Aktualisierung der Aufgabendefinition vor, indem Sie ein Tag hinzufügen. Erstellen Sie unten auf der Seite unter **Tags** ein neues Tag, indem Sie ein neues Schlüssel- und Wert-Paar eingeben. 

1.  Wählen Sie **Erstellen** aus. Sie sollten sehen, dass die Versionsnummer Ihrer Aufgabendefinition um eins erhöht wurde. 

1.  Wählen Sie den Tab **JSON**. Notieren Sie sich den Wert für `taskDefinitionArn`. Das Format ist `arn:aws:ecs:aws-region: account-id:task-definition/task-definition-family: task-definition-revision`. Dies ist der ARN Ihrer aktualisierten Aufgabendefinition. 

# Schritt 3: Erstellen Sie eine Lifecycle-Hook-Lambda-Funktion
<a name="tutorial-ecs-with-hooks-create-hooks"></a>

In diesem Abschnitt implementieren Sie eine Lambda-Funktion für den `AfterAllowTestTraffic` Hook Ihrer Amazon ECS-Bereitstellung. Die Lambda-Funktion führt einen Validierungstest durch, bevor die aktualisierte Amazon ECS-Anwendung installiert wird. Für dieses Tutorial kehrt die Lambda-Funktion zurück`Succeeded`. Während einer realen Bereitstellung geben Validierungstests `Succeeded` oder `Failed` zurück, abhängig vom Ergebnis des Validierungstests. Während einer realen Bereitstellung können Sie auch eine Lambda-Testfunktion für einen oder mehrere der anderen Event-Hooks (`BeforeInstall`, `AfterInstall``BeforeAllowTraffic`, und`AfterAllowTraffic`) des Amazon ECS-Bereitstellungslebenszyklus implementieren. Weitere Informationen finden Sie unter [Liste der Lifecycle-Event-Hooks für eine Amazon ECS-Bereitstellung](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs).

 Eine IAM-Rolle ist erforderlich, um Ihre Lambda-Funktion zu erstellen. Die Rolle gewährt der Lambda-Funktion die Berechtigung, in CloudWatch Logs zu schreiben und den Status eines CodeDeploy Lifecycle-Hooks festzulegen. 

**So erstellen Sie eine IAM-Rolle**

1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

1. Wählen Sie im Navigationsbereich **Roles (Rollen)** und dann **Create role (Rolle erstellen)** aus.

1.  Erstellen Sie eine Rolle mit den folgenden Eigenschaften: 
   +  **Trusted entity (Vertrauenswürdige Entität)**: **AWS Lambda**. 
   +  **Berechtigungen**: **AWSLambdaBasicExecutionRole**. Dadurch wird Ihrer Lambda-Funktion die Berechtigung erteilt, in CloudWatch Logs zu schreiben. 
   +  **Role name (Name der Rolle)**: **`lambda-cli-hook-role`**. 

   Weitere Informationen finden Sie unter [Eine AWS Lambda Ausführungsrolle erstellen](https://docs.aws.amazon.com/lambda/latest/dg/with-userapp.html#with-userapp-walkthrough-custom-events-create-iam-role). 

1.  Fügen Sie die Berechtigung `codedeploy:PutLifecycleEventHookExecutionStatus` an die Rolle an, die Sie erstellt haben. Dadurch erhalten Ihre Lambda-Funktionen die Berechtigung, den Status eines CodeDeploy Lifecycle-Hooks während einer Bereitstellung festzulegen. Weitere Informationen finden Sie unter [Hinzufügen von IAM-Identitätsberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) im *AWS Identity and Access Management Benutzerhandbuch* und [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html)in der *CodeDeploy API-Referenz*. 

**Um eine `AfterAllowTestTraffic` Hook-Lambda-Funktion zu erstellen**

1.  Erstellen Sie eine Datei mit dem Namen `AfterAllowTestTraffic.js` und dem folgenden Inhalt. 

   ```
   'use strict';
    
    const AWS = require('aws-sdk');
    const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
    
    exports.handler = (event, context, callback) => {
    
    	console.log("Entering AfterAllowTestTraffic hook.");
    	
    	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
     var deploymentId = event.DeploymentId;
    	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
    	var validationTestResult = "Failed";
    	
    	// Perform AfterAllowTestTraffic validation tests here. Set the test result 
    	// to "Succeeded" for this tutorial.
    	console.log("This is where AfterAllowTestTraffic validation tests happen.")
    	validationTestResult = "Succeeded";
    	
    	// Complete the AfterAllowTestTraffic hook by sending CodeDeploy the validation status
    	var params = {
    		deploymentId: deploymentId,
    		lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
    		status: validationTestResult // status can be 'Succeeded' or 'Failed'
    	};
    	
    	// Pass CodeDeploy the prepared validation test results.
    	codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
    		if (err) {
    			// Validation failed.
    			console.log('AfterAllowTestTraffic validation tests failed');
    			console.log(err, err.stack);
    			callback("CodeDeploy Status update failed");
    		} else {
    			// Validation succeeded.
    			console.log("AfterAllowTestTraffic validation tests succeeded");
    			callback(null, "AfterAllowTestTraffic validation tests succeeded");
    		}
    	});
    }
   ```

1.  Erstellen Sie ein Lambda-Bereitstellungspaket. 

   ```
   zip AfterAllowTestTraffic.zip AfterAllowTestTraffic.js 
   ```

1.  Verwenden Sie den `create-function` Befehl, um eine Lambda-Funktion für Ihren `AfterAllowTestTraffic` Hook zu erstellen. 

   ```
   aws lambda create-function --function-name AfterAllowTestTraffic \
          --zip-file fileb://AfterAllowTestTraffic.zip \
          --handler AfterAllowTestTraffic.handler \
          --runtime nodejs10.x \
          --role arn:aws:iam::aws-account-id:role/lambda-cli-hook-role
   ```

1.  Notieren Sie sich den ARN Ihrer Lambda-Funktion in der `create-function` Antwort. Sie verwenden diesen ARN, wenn Sie die AppSpec Datei Ihres CodeDeploy Deployments im nächsten Schritt aktualisieren. 

# Schritt 4: Aktualisieren Sie Ihre AppSpec Datei
<a name="tutorial-ecs-with-hooks-create-appspec-file"></a>

 In diesem Abschnitt aktualisieren Sie Ihre AppSpec Datei mit einem `Hooks` Abschnitt. In dem `Hooks` Abschnitt geben Sie eine Lambda-Funktion für den `AfterAllowTestTraffic` Lifecycle-Hook an. 

**Um Ihre AppSpec Datei zu aktualisieren**

1.  Öffnen Sie die AppSpec Dateidatei, die Sie in [Schritt 2: Erstellen Sie die Datei AppSpec](tutorial-ecs-create-appspec-file.md) der erstellt haben[Tutorial: Bereitstellen einer Anwendung in Amazon ECS](tutorial-ecs-deployment.md). 

1.  Aktualisieren Sie die `TaskDefinition`-Eigenschaft mit dem Aufgabendefinitions-ARN, den Sie sich in [Schritt 2: Aktualisieren Sie Ihre Amazon ECS-Anwendung](tutorial-ecs-with-hooks-update-the-ecs-application.md) notiert haben. 

1. Kopieren Sie den `Hooks` Abschnitt und fügen Sie ihn in Ihre AppSpec Dateidatei ein. Aktualisieren Sie den ARN anschließend `AfterAllowTestTraffic` mit dem ARN der Lambda-Funktion, die Sie notiert [Schritt 3: Erstellen Sie eine Lifecycle-Hook-Lambda-Funktion](tutorial-ecs-with-hooks-create-hooks.md) haben. 

------
#### [ JSON AppSpec ]

   ```
   {
     "version": 0.0,
     "Resources": [
       {
         "TargetService": {
           "Type": "AWS::ECS::Service",
           "Properties": {
             "TaskDefinition": "arn:aws:ecs:aws-region-id:aws-account-id::task-definition/ecs-demo-task-definition:revision-number",
             "LoadBalancerInfo": {
               "ContainerName": "sample-website",
               "ContainerPort": 80
             }
           }
         }
       }
     ],
     "Hooks": [
       {
         "AfterAllowTestTraffic": "arn:aws:lambda:aws-region-id:aws-account-id:function:AfterAllowTestTraffic"
       }
     ]
   }
   ```

------
#### [ YAML AppSpec ]

   ```
   version: 0.0
   Resources:
     - TargetService:
         Type: AWS::ECS::Service
         Properties:
           TaskDefinition: "arn:aws:ecs:aws-region-id:aws-account-id::task-definition/ecs-demo-task-definition:revision-number"
           LoadBalancerInfo:
             ContainerName: "sample-website"
             ContainerPort: 80
   Hooks:
     - AfterAllowTestTraffic: "arn:aws:lambda:aws-region-id:aws-account-id:function:AfterAllowTestTraffic"
   ```

------

1.  Speichern Sie Ihre AppSpec Datei und laden Sie sie in den zugehörigen S3-Bucket hoch. 

# Schritt 5: Verwenden Sie die CodeDeploy Konsole, um Ihren Amazon ECS-Service bereitzustellen
<a name="tutorial-ecs-with-hooks-deployment"></a>

 In diesem Abschnitt aktualisieren Sie Ihre Bereitstellungsgruppe, indem Sie den Port für Ihren Test-Listener angeben. Dies ist der Listener, den Sie in [Schritt 1: Erstellen Sie einen Test-Listener](tutorial-ecs-with-hooks-create-second-listener.md) erstellt haben. Während der Bereitstellung führt CodeDeploy Ihren Validierungstest während des `AfterAllowTestTraffic`-Bereitstellungslebenszyklus-Hooks mithilfe von Testdatenverkehr aus, der an Ihren neuen Aufgabensatz mit dem Test-Listener geleitet wird. Ihr Validierungstest gibt das Ergebnis `Succeeded` zurück, sodass die Bereitstellung mit dem nächsten Bereitstellungslebenszyklusereignis fortgesetzt wird. In einem realen Szenario gibt Ihre Testfunktion `Succeeded` oder `Failed` zurück. 

**So fügen Sie Ihrer Bereitstellungsgruppe einen Test-Listener hinzu**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).

1. Wählen Sie im Navigationsbereich **Applications (Anwendungen)** aus. 

1. Wählen Sie die Anwendung aus, die Sie in [Tutorial: Bereitstellen einer Anwendung in Amazon ECS](tutorial-ecs-deployment.md) erstellt haben. Wenn Sie den vorgeschlagenen Namen verwendet haben, lautet er **ecs-demo-codedeploy-app**.

1. Wählen Sie unter **Deployment groups (Bereitstellungsgruppen)** die Bereitstellungsgruppe aus, die Sie in [Tutorial: Bereitstellen einer Anwendung in Amazon ECS](tutorial-ecs-deployment.md) erstellt haben. Wenn Sie den vorgeschlagenen Namen verwendet haben, lautet er **ecs-demo-dg**.

1.  Wählen Sie **Bearbeiten** aus. 

1. Wählen Sie unter **Test listener port (Test-Listener-Port)** den Port und das Protokoll für den Test-Listener aus, den Sie zuvor in diesem Tutorial erstellt haben. Dies sollte **HTTP: 8080** sein. 

1.  Wählen Sie **Änderungen speichern ** aus. 

**So stellen Sie Ihre Amazon ECS-Anwendung bereit**

1. Wählen Sie auf der Konsolenseite Ihrer Bereitstellungsgruppe **Create deployment (Bereitstellung erstellen)** aus.

1.  Wählen Sie als **Bereitstellungsgruppe** die Option **ecs-demo-dg**. 

1.  Wählen Sie unter **Revision type (Revisionstyp)** die Option **My application is stored in Amazon S3 (Meine Anwendung ist in Amazon S3 gespeichert)** aus. Geben Sie **unter Revisionsort** den Namen Ihres S3-Buckets und der AppSpec Datei ein (z. B.**s3://my-s3-bucket/appspec.json**). 

1.  Wählen Sie für **Revision file type (Revisionsdateityp)** die Option **.json** oder **.yaml** aus. 

1.  (Optional) Geben Sie im Feld **Deployment description (Bereitstellungsbeschreibung)** eine Beschreibung für Ihre Bereitstellung ein. 

1. Wählen Sie **Create deployment**.

 Sie können Ihre Bereitstellung im **Deployment status (Bereitstellungsstatus)** überwachen. Nachdem der gesamte Produktionsdatenverkehr an den Ersatz-Tasksatz weitergeleitet wurde, können Sie „**Ursprünglichen Tasksatz beenden**“ wählen, um den ursprünglichen Tasksatz sofort zu beenden. Wenn Sie **Terminate original task set (Urprünglichen Aufgabensatz beenden)** nicht auswählen, wird der ursprüngliche Aufgabensatz nach der Dauer beendet, die Sie beim Erstellen Ihrer Bereitstellungsgruppe angegeben haben. 

![\[Der Abschnitt mit dem Bereitstellungsstatus der CodeDeploy Konsole.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/ecs-tutorial-deployment-status-with-test-listener.png)


# Schritt 6: Zeigen Sie die Ausgabe Ihrer Lambda-Hook-Funktion in Logs an CloudWatch
<a name="tutorial-ecs-with-hooks-view-cw-logs"></a>

 Wenn Ihre CodeDeploy Bereitstellung erfolgreich ist, sind auch die Validierungstests in Ihren Lambda-Hook-Funktionen erfolgreich. Sie können dies überprüfen, indem Sie im Protokoll unter Logs nach der Hook-Funktion suchen. CloudWatch 

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1.  Wählen Sie im Navigationsbereich **Logs (Protokolle)** aus. Sie sollten eine neue Protokollgruppe für die Lambda-Hook-Funktion sehen, die Sie in Ihrer AppSpec Datei angegeben haben.   
![\[Die neue Protokollgruppe in der CloudWatch Konsole.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/ecs-demo-cw-logs.png)

1.  Wählen Sie die neue Protokollgruppe aus. Das sollte**/**seinaws/lambda/AfterAllowTestTrafficHook. 

1.  Wählen Sie den Protokollstream. Wenn Sie mehr als einen Protokoll-Stream sehen, wählen Sie unter **Last Event Time (Letzte Ereigniszeit)** denjenigen mit dem neuesten Datum und der aktuellen Uhrzeit aus. 

1.  Erweitern Sie die Protokollstream-Ereignisse, um zu bestätigen, dass Ihre Lambda-Hook-Funktion Erfolgsmeldungen in das Protokoll geschrieben hat. Das Folgende zeigt, dass die `AfterAllowTraffic` Lambda-Hook-Funktion erfolgreich war.   
![\[Die Logstream-Ereignisse, die den AfterAllowTraffic Hook zeigen.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/ecs-demo-cw-log-events.png)

# Schritt 7: Bereinigen
<a name="tutoria-ecs-with-hooks-clean-up"></a>

 Wenn Sie dieses Tutorial abgeschlossen haben, sollten Sie die damit verknüpften Ressourcen bereinigen, um zu vermeiden, dass für nicht verwendete Ressourcen Kosten entstehen. Bei den Ressourcennamen in diesem Schritt handelt es sich um die in diesem Tutorial vorgeschlagenen Namen (z. B. **ecs-demo-codedeploy-app** für den Namen Ihrer CodeDeploy Anwendung). Wenn Sie verschiedene Namen verwendet haben, stellen Sie sicher, dass Sie diese in Ihrer Bereinigung verwenden. 

**So bereinigen Sie die Tutorial-Ressourcen**

1. Verwenden Sie den [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)Befehl, um die CodeDeploy Bereitstellungsgruppe zu löschen.

   ```
   aws deploy delete-deployment-group --application-name ecs-demo-deployment-group --deployment-group-name ecs-demo-dg --region aws-region-id
   ```

1. Verwenden Sie den Befehl [delete-application, um die Anwendung](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) zu löschen. CodeDeploy 

   ```
   aws deploy delete-application --application-name ecs-demo-deployment-group --region aws-region-id
   ```

1. Verwenden Sie den Befehl [delete-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/delete-function.html), um Ihre Lambda-Hook-Funktion zu löschen.

   ```
   aws lambda delete-function --function-name AfterAllowTestTraffic
   ```

1. Verwenden Sie den [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html)Befehl, um Ihre Protokollgruppe zu löschen. CloudWatch 

   ```
   aws logs delete-log-group --log-group-name /aws/lambda/AfterAllowTestTraffic
   ```

# Tutorial: Bereitstellen einer aktualisierten Lambda-Funktion mit CodeDeploy und dem AWS Serverless Application Model
<a name="tutorial-lambda-sam"></a>

AWS SAM ist ein Open-Source-Framework für die Erstellung serverloser Anwendungen. Es transformiert und erweitert die YAML-Syntax in einer AWS SAM Vorlage in eine CloudFormation Syntax, um serverlose Anwendungen wie eine Lambda-Funktion zu erstellen. Weitere Informationen finden Sie unter [Was ist das serverlose Anwendungsmodell? AWS](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) 

 In diesem Tutorial verwenden Sie AWS SAM, um eine Lösung zu erstellen, die Folgendes bietet: 
+  Erzeugt Ihre Lambda-Funktion. 
+  Erstellt Ihre CodeDeploy Anwendung und Bereitstellungsgruppe. 
+  Erstellt zwei Lambda-Funktionen, die Bereitstellungsvalidierungstests während CodeDeploy Lifecycle-Hooks ausführen. 
+  Erkennt, wenn Ihre Lambda-Funktion aktualisiert wird. Die Aktualisierung der Lambda-Funktion löst eine Bereitstellung aus CodeDeploy , bei der der Produktionsverkehr schrittweise von der ursprünglichen Version Ihrer Lambda-Funktion auf die aktualisierte Version verlagert wird. 

**Anmerkung**  
In diesem Tutorial müssen Sie Ressourcen erstellen, die möglicherweise Kosten für Ihr AWS -Konto verursachen. Dazu gehören mögliche Gebühren für CodeDeploy Amazon CloudWatch und AWS Lambda. Weitere Informationen finden Sie unter [CodeDeploy Preise](https://aws.amazon.com/codedeploy/pricing/), [ CloudWatch Amazon-Preise](https://aws.amazon.com/cloudwatch/pricing/) und [AWS Lambda Preise](https://aws.amazon.com/lambda/pricing/).

**Topics**
+ [Voraussetzungen](tutorial-lambda-sam-prereqs.md)
+ [Schritt 1: Richten Sie Ihre Infrastruktur ein](tutorial-lambda-sam-setup-infrastructure.md)
+ [Schritt 2: Aktualisieren Sie die Lambda-Funktion](tutorial-lambda-sam-update-function.md)
+ [Schritt 3: Stellen Sie die aktualisierte Lambda-Funktion bereit](tutorial-lambda-sam-deploy-update.md)
+ [Schritt 4: Zeigen Sie Ihre Bereitstellungsergebnisse an](tutorial-lambda-sam-deploy-view-results.md)
+ [Schritt 5: Bereinigen](tutorial-lambda-clean-up.md)

# Voraussetzungen
<a name="tutorial-lambda-sam-prereqs"></a>

Um dieses Tutorial abzuschließen, müssen Sie zunächst:
+  Führen Sie die Schritte unter [Erste Schritte mit CodeDeploy](getting-started-codedeploy.md) aus. 
+  Installieren Sie die AWS Serverless Application Model CLI. Weitere Informationen finden [Sie unter AWS SAM-CLI installieren](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). 
+  Erstellen Sie einen S3-Bucket. AWS SAM lädt die Artefakte, auf die in Ihrer [AWS SAM-Vorlage](https://docs.aws.amazon.com/en_us/codedeploy/latest/userguide/tutorial-lambda-sam-template.html) verwiesen wird, in diesen Bucket hoch. 

# Schritt 1: Richten Sie Ihre Infrastruktur ein
<a name="tutorial-lambda-sam-setup-infrastructure"></a>

 In diesem Thema erfahren Sie, wie Sie Dateien für Ihre AWS SAM Vorlage und Ihre Lambda-Funktionen erstellen. AWS SAM Anschließend verwenden Sie die `deploy` Befehle AWS SAM `package` und, um die Komponenten in Ihrer Infrastruktur zu generieren. Wenn Ihre Infrastruktur bereit ist, haben Sie eine CodeDeploy Anwendungs- und Bereitstellungsgruppe, die Lambda-Funktion zum Aktualisieren und Bereitstellen sowie zwei Lambda-Funktionen, die Validierungstests enthalten, die ausgeführt werden, wenn Sie die Lambda-Funktion bereitstellen. Wenn Sie fertig sind, können CloudFormation Sie Ihre Komponenten in der Lambda-Konsole anzeigen oder Ihre Lambda-Funktion testen. AWS CLI 

**Topics**
+ [Erstellen Sie Ihre Dateien](tutorial-lambda-create-files.md)
+ [Die AWS SAM-Anwendung verpacken](tutorial-lambda-sam-package.md)
+ [Stellen Sie die AWS SAM-Anwendung bereit](tutorial-lambda-sam-deploy.md)
+ [(Optional) inspizieren und testen Sie Ihre Infrastruktur](tutorial-lambda-sam-confirm-components.md)

# Erstellen Sie Ihre Dateien
<a name="tutorial-lambda-create-files"></a>

 Um Ihre Infrastruktur zu erstellen, müssen Sie die folgenden Dateien erstellen: 
+ `template.yml`
+ `myDateTimeFunction.js`
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`

**Topics**
+ [Erstellen Sie Ihre AWS SAM-Vorlage](tutorial-lambda-sam-template.md)
+ [Erstellen Sie eine Datei für Ihre Lambda-Funktion](tutorial-lambda-sam-create-lambda-function.md)
+ [Erstellen Sie eine Datei für Ihre BeforeAllowTraffic Lambda-Funktion](tutorial-lambda-sam-create-lambda-before-traffic.md)
+ [Erstellen Sie eine Datei für Ihre AfterAllowTraffic Lambda-Funktion](tutorial-lambda-sam-create-lambda-after-traffic.md)

# Erstellen Sie Ihre AWS SAM-Vorlage
<a name="tutorial-lambda-sam-template"></a>

Erstellen Sie eine AWS SAM-Vorlagendatei, die die Komponenten in Ihrer Infrastruktur spezifiziert.

**Um Ihre AWS SAM-Vorlage zu erstellen**

1.  Erstellen Sie ein Verzeichnis mit dem Namen `SAM-Tutorial`. 

1.  Erstellen Sie in Ihrem Verzeichnis `SAM-Tutorial` eine Datei namens `template.yml`. 

1.  Kopieren Sie den folgenden YAML-Code in `template.yml`. Dies ist Ihre AWS SAM -Vorlage. 

   ```
   AWSTemplateFormatVersion : '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: A sample SAM template for deploying Lambda functions.
   
   Resources:
   # Details about the myDateTimeFunction Lambda function
     myDateTimeFunction:
       Type: AWS::Serverless::Function
       Properties:
         Handler: myDateTimeFunction.handler
         Runtime: nodejs18.x
   # Instructs your myDateTimeFunction is published to an alias named "live".      
         AutoPublishAlias: live
   # Grants this function permission to call lambda:InvokeFunction
         Policies:
           - Version: "2012-10-17"		 	 	 
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: '*'
         DeploymentPreference:
   # Specifies the deployment configuration      
             Type: Linear10PercentEvery1Minute
   # Specifies Lambda functions for deployment lifecycle hooks
             Hooks:
               PreTraffic: !Ref beforeAllowTraffic
               PostTraffic: !Ref afterAllowTraffic
               
   # Specifies the BeforeAllowTraffic lifecycle hook Lambda function
     beforeAllowTraffic:
       Type: AWS::Serverless::Function
       Properties:
         Handler: beforeAllowTraffic.handler
         Policies:
           - Version: "2012-10-17"		 	 	 
   # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus        
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "codedeploy:PutLifecycleEventHookExecutionStatus"
               Resource:
                 !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
           - Version: "2012-10-17"		 	 	 
   # Grants this function permission to call lambda:InvokeFunction        
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: !Ref myDateTimeFunction.Version
         Runtime: nodejs18.x
   # Specifies the name of the Lambda hook function      
         FunctionName: 'CodeDeployHook_beforeAllowTraffic'
         DeploymentPreference:
           Enabled: false
         Timeout: 5
         Environment:
           Variables:
             NewVersion: !Ref myDateTimeFunction.Version
             
   # Specifies the AfterAllowTraffic lifecycle hook Lambda function
     afterAllowTraffic:
       Type: AWS::Serverless::Function
       Properties:
         Handler: afterAllowTraffic.handler
         Policies:
           - Version: "2012-10-17"		 	 	 
             Statement: 
   # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus         
             - Effect: "Allow"
               Action: 
                 - "codedeploy:PutLifecycleEventHookExecutionStatus"
               Resource:
                 !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
           - Version: "2012-10-17"		 	 	 
             Statement: 
   # Grants this function permission to call lambda:InvokeFunction          
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: !Ref myDateTimeFunction.Version
         Runtime: nodejs18.x
   # Specifies the name of the Lambda hook function      
         FunctionName: 'CodeDeployHook_afterAllowTraffic'
         DeploymentPreference:
           Enabled: false
         Timeout: 5
         Environment:
           Variables:
             NewVersion: !Ref myDateTimeFunction.Version
   ```

Diese Vorlage gibt Folgendes an. Weitere Informationen finden Sie unter [AWS SAM Vorlagenkonzepte](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html).

**Eine Lambda-Funktion namens `myDateTimeFunction`**  
 Wenn diese Lambda-Funktion veröffentlicht wird, verknüpft sie die `AutoPublishAlias` Zeile in der Vorlage mit einem Alias namens`live`. Später in diesem Tutorial löst ein Update dieser Funktion eine Bereitstellung aus, bei der der Produktionsdatenverkehr schrittweise von der Originalversion auf die aktualisierte Version verlagert wird. AWS CodeDeploy 

**Zwei Validierungsfunktionen für die Lambda-Bereitstellung**  
 Die folgenden Lambda-Funktionen werden während CodeDeploy Lifecycle-Hooks ausgeführt. Die Funktionen enthalten Code, der die Bereitstellung der aktualisierten `myDateTimeFunction` validiert. Das Ergebnis der Validierungstests wird mithilfe der `PutLifecycleEventHookExecutionStatus`-API-Methode an CodeDeploy übergeben. Wenn ein Validierungstest fehlschlägt, schlägt die Bereitstellung fehl und wird zurückgesetzt.   
+  `CodeDeployHook_beforeAllowTraffic` wird während des `BeforeAllowTraffic`-Hooks ausgeführt. 
+  `CodeDeployHook_afterAllowTraffic` wird während des `AfterAllowTraffic`-Hooks ausgeführt. 
Der Name beider Funktionen beginnt mit `CodeDeployHook_`. Die `CodeDeployRoleForLambda` Rolle erlaubt Aufrufe der `invoke` Lambda-Methode nur in Lambda-Funktionen, deren Namen mit diesem Präfix beginnen. Weitere Informationen finden Sie unter [AppSpec Abschnitt „Hooks“ für eine AWS Lambda-Bereitstellung](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda) und [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html) in der *CodeDeploy -API-Referenz*. 

**Automatische Erkennung einer aktualisierten Lambda-Funktion**  
 Der `AutoPublishAlias`-Begriff weist das Framework an, zu erkennen, wenn sich die `myDateTimeFunction`-Funktion ändert, und sie dann mit dem `live`-Alias bereitzustellen. 

**Eine Bereitstellungskonfiguration**  
 Die Bereitstellungskonfiguration bestimmt die Geschwindigkeit, mit der Ihre CodeDeploy Anwendung den Datenverkehr von der ursprünglichen Version der Lambda-Funktion auf die neue Version verlagert. Diese Vorlage gibt die vordefinierte Bereitstellungskonfiguration `Linear10PercentEvery1Minute` an.   
 Sie können keine benutzerdefinierte Bereitstellungskonfiguration in einer AWS SAM-Vorlage angeben. Weitere Informationen finden Sie unter [Erstellen Sie eine Bereitstellungskonfiguration mit CodeDeploy](deployment-configurations-create.md).

**Funktionen von Bereitstellungslebenszyklus-Hooks**  
 Der `Hooks`-Abschnitt gibt die Funktionen an, die während Lebenszyklusereignis-Hooks ausgeführt werden. `PreTraffic` gibt die Funktion an, die während des `BeforeAllowTraffic`-Hooks ausgeführt wird. `PostTraffic` gibt die Funktion an, die während des `AfterAllowTraffic`-Hooks ausgeführt wird. 

**Berechtigungen für Lambda zum Aufrufen einer anderen Lambda-Funktion**  
 Die angegebene `lambda:InvokeFunction` Berechtigung gewährt der von der AWS SAM-Anwendung verwendeten Rolle die Berechtigung, eine Lambda-Funktion aufzurufen. Dies ist erforderlich, wenn die `CodeDeployHook_afterAllowTraffic` Funktionen `CodeDeployHook_beforeAllowTraffic` und die bereitgestellte Lambda-Funktion während der Validierungstests aufrufen. 

# Erstellen Sie eine Datei für Ihre Lambda-Funktion
<a name="tutorial-lambda-sam-create-lambda-function"></a>

Erstellen Sie die Datei für die Funktion, die Sie später in diesem Tutorial aktualisieren und bereitstellen.

**Anmerkung**  
 Eine Lambda-Funktion kann jede Laufzeit verwenden, die von AWS Lambda unterstützt wird. Weitere Informationen finden Sie unter [AWS Lambda -Laufzeiten](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). 

**Um Ihre Lambda-Funktion zu erstellen**

1.  Erstellen Sie eine Textdatei und speichern Sie sie als `myDateTimeFunction.js` im `SAM-Tutorial`-Verzeichnis. 

1.  Kopieren Sie den folgenden Node.js-Code in `myDateTimeFunction.js`. 

   

   ```
   'use strict';
       
       exports.handler = function(event, context, callback) {
       
         if (event.body) {
           event = JSON.parse(event.body);
         }
       
         var sc; // Status code
         var result = ""; // Response payload
       
         switch(event.option) {
           case "date": 
             switch(event.period) {
               case "yesterday":
                 result = setDateResult("yesterday");
                 sc = 200;
                 break;
               case "today":
                 result = setDateResult();
                 sc = 200;
                 break;
               case "tomorrow":
                 result = setDateResult("tomorrow");
                 sc = 200;
                 break;
               default:
                 result = {
                   "error": "Must specify 'yesterday', 'today', or 'tomorrow'."
                 };
                 sc = 400;
                 break;
             }
             break;
             
       /*      Later in this tutorial, you update this function by uncommenting 
               this section. The framework created by AWS SAM detects the update 
               and triggers a deployment by CodeDeploy. The deployment shifts 
               production traffic to the updated version of this function.
               
               case "time":
               var d = new Date();
               var h = d.getHours();
               var mi = d.getMinutes();
               var s = d.getSeconds();
       
               result = {
                 "hour": h,
                 "minute": mi,
                 "second": s
               };
               sc = 200;
               break;
       */
             default:
               result = {
                 "error": "Must specify 'date' or 'time'."
               };
               sc = 400;
             break;
         }
       
         const response = {
           statusCode: sc,
           headers: { "Content-type": "application/json" },
           body: JSON.stringify( result )
         };
       
         callback(null, response);
       
         function setDateResult(option) {
       
           var d = new Date(); // Today
           var mo; // Month
           var da; // Day
           var y; // Year
       
           switch(option) {
             case "yesterday":
               d.setDate(d.getDate() - 1);
               break;
             case "tomorrow":
               d.setDate(d.getDate() + 1);
             default:
              break;
           }
       
           mo = d.getMonth() + 1; // Months are zero offset (0-11)
           da = d.getDate();
           y = d.getFullYear();
       
           result = {
             "month": mo,
             "day": da,
             "year": y
           };
       
           return result;
         }
       };
   ```

Die Lambda-Funktion gibt den Tag, den Monat und das Jahr für gestern, heute oder morgen zurück. Später in diesem Tutorial entfernen Sie die Kommentarzeichen von Code, der die Funktion aktualisiert, um Informationen über den Tag oder die Uhrzeit zurückzugeben, die Sie angeben (z. B. Tag, Monat und Jahr oder die aktuelle Stunde, Minute und Sekunde). Das von erstellte Framework AWS SAM erkennt die aktualisierte Version der Funktion und stellt sie bereit. 

**Anmerkung**  
 Diese Lambda-Funktion wird auch in einem AWS Cloud9 Tutorial verwendet. AWS Cloud9 ist eine cloudbasierte integrierte Entwicklungsumgebung. Informationen zum Erstellen, Ausführen, Aktualisieren und Debuggen dieser Funktion finden Sie unter [AWS Lambda Tutorial für AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial-lambda.html). AWS Cloud9

# Erstellen Sie eine Datei für Ihre BeforeAllowTraffic Lambda-Funktion
<a name="tutorial-lambda-sam-create-lambda-before-traffic"></a>

Erstellen Sie die Datei für Ihre `beforeAllowTraffic` Hook-Lambda-Funktion.

1.  Erstellen Sie eine Textdatei und speichern Sie sie als `beforeAllowTraffic.js` im `SAM-Tutorial`-Verzeichnis. 

1.  Kopieren Sie den folgenden Node.js-Code in `beforeAllowTraffic.js`. Diese Funktion wird während des `BeforeAllowTraffic`-Hooks Ihrer Bereitstellung ausgeführt. 

   ```
   'use strict';
       
       const AWS = require('aws-sdk'); 
       const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
       var lambda = new AWS.Lambda();
       
       exports.handler = (event, context, callback) => {
       
       	console.log("Entering PreTraffic Hook!");
       	
       	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
         var deploymentId = event.DeploymentId;
       	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
       
       	var functionToTest = process.env.NewVersion;
       	console.log("BeforeAllowTraffic hook tests started");
       	console.log("Testing new function version: " + functionToTest);
       
       	// Create parameters to pass to the updated Lambda function that
       	// include the newly added "time" option. If the function did not
       	// update, then the "time" option is invalid and function returns
       	// a statusCode of 400 indicating it failed.
       	var lambdaParams = {
       		FunctionName: functionToTest,    
       		Payload: "{\"option\": \"time\"}", 
       		InvocationType: "RequestResponse"
       	};
       
       	var lambdaResult = "Failed";
       	// Invoke the updated Lambda function.
       	lambda.invoke(lambdaParams, function(err, data) {
       		if (err){	// an error occurred
       			console.log(err, err.stack);
       			lambdaResult = "Failed";
       		}
       		else{	// successful response
       			var result = JSON.parse(data.Payload);
       			console.log("Result: " +  JSON.stringify(result));
             console.log("statusCode: " + result.statusCode);
             
             // Check if the status code returned by the updated
             // function is 400. If it is, then it failed. If 
             // is not, then it succeeded.
       			if (result.statusCode != "400"){
               console.log("Validation succeeded");
       				lambdaResult = "Succeeded";
             }
             else {
               console.log("Validation failed");
             }
       
       			// Complete the PreTraffic Hook by sending CodeDeploy the validation status
       			var params = {
       				deploymentId: deploymentId,
       				lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
       				status: lambdaResult // status can be 'Succeeded' or 'Failed'
       			};
       			
       			// Pass CodeDeploy the prepared validation test results.
       			codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
       				if (err) {
       					// Validation failed.
       					console.log("CodeDeploy Status update failed");
       					console.log(err, err.stack);
       					callback("CodeDeploy Status update failed");
       				} else {
       					// Validation succeeded.
       					console.log("CodeDeploy status updated successfully");
       					callback(null, "CodeDeploy status updated successfully");
       				}
       			});
       		}  
       	});
       }
   ```

# Erstellen Sie eine Datei für Ihre AfterAllowTraffic Lambda-Funktion
<a name="tutorial-lambda-sam-create-lambda-after-traffic"></a>

Erstellen Sie die Datei für Ihre `afterAllowTraffic` Hook-Lambda-Funktion.

1.  Erstellen Sie eine Textdatei und speichern Sie sie als `afterAllowTraffic.js` im `SAM-Tutorial`-Verzeichnis. 

1.  Kopieren Sie den folgenden Node.js-Code in `afterAllowTraffic.js`. Diese Funktion wird während des `AfterAllowTraffic`-Hooks Ihrer Bereitstellung ausgeführt. 

   ```
   'use strict';
       
       const AWS = require('aws-sdk');
       const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
       var lambda = new AWS.Lambda();
       
       exports.handler = (event, context, callback) => {
       
       	console.log("Entering PostTraffic Hook!");
       	
       	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
         var deploymentId = event.DeploymentId;
       	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
       
       	var functionToTest = process.env.NewVersion;
       	console.log("AfterAllowTraffic hook tests started");
       	console.log("Testing new function version: " + functionToTest);
       
       	// Create parameters to pass to the updated Lambda function that
       	// include the original "date" parameter. If the function did not 
       	// update as expected, then the "date" option might be invalid. If 
       	// the parameter is invalid, the function returns
       	// a statusCode of 400 indicating it failed.
       	var lambdaParams = {
       		FunctionName: functionToTest,    
       		Payload: "{\"option\": \"date\", \"period\": \"today\"}", 
       		InvocationType: "RequestResponse"
       	};
       
       	var lambdaResult = "Failed";
       	// Invoke the updated Lambda function.
       	lambda.invoke(lambdaParams, function(err, data) {
       		if (err){	// an error occurred
       			console.log(err, err.stack);
       			lambdaResult = "Failed";
       		}
       		else{	// successful response
       			var result = JSON.parse(data.Payload);
       			console.log("Result: " +  JSON.stringify(result));
             console.log("statusCode: " + result.statusCode);
             
             // Check if the status code returned by the updated
             // function is 400. If it is, then it failed. If 
             // is not, then it succeeded.
       			if (result.statusCode != "400"){
               console.log("Validation of time parameter succeeded");
       				lambdaResult = "Succeeded";
             }
             else {
               console.log("Validation failed");
             }
       
       			// Complete the PostTraffic Hook by sending CodeDeploy the validation status
       			var params = {
       				deploymentId: deploymentId,
       				lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
       				status: lambdaResult // status can be 'Succeeded' or 'Failed'
       			};
       			
       			// Pass CodeDeploy the prepared validation test results.
       			codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
       				if (err) {
       					// Validation failed.
       					console.log("CodeDeploy Status update failed");
       					console.log(err, err.stack);
       					callback("CodeDeploy Status update failed");
       				} else {
       					// Validation succeeded.
       					console.log("CodeDeploy status updated successfully");
       					callback(null, "CodeDeploy status updated successfully");
       				}
       			});
       		}  
       	});
       }
   ```

# Die AWS SAM-Anwendung verpacken
<a name="tutorial-lambda-sam-package"></a>

 Sie sollten nun vier Dateien in Ihrem `SAM-Tutorial`-Verzeichnis haben: 
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`
+ `myDateTimeFunction.js`
+ `template.yml`

 Sie können jetzt den AWS **sam package** SAM-Befehl verwenden, um Artefakte für Ihre Lambda-Funktionen und CodeDeploy -Anwendungen zu erstellen und zu verpacken. Die Artefakte werden in einen S3-Bucket hochgeladen. Die Ausgabe des Befehls ist eine neue Datei mit dem Namen `package.yml`. Diese Datei wird im nächsten Schritt vom AWS **sam deploy** SAM-Befehl verwendet. 

**Anmerkung**  
 Weitere Informationen zu diesem **sam package** Befehl finden Sie in der [AWS SAM CLI-Befehlsreferenz](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) im *AWS Serverless Application Model Entwicklerhandbuch*. 

 Führen Sie Folgendes im `SAM-Tutorial`-Verzeichnis aus. 

```
sam package \
  --template-file template.yml \
  --output-template-file package.yml \
  --s3-bucket amzn-s3-demo-bucket
```

Geben Sie für den `s3-bucket` Parameter den Amazon S3 S3-Bucket an, den Sie als Voraussetzung für dieses Tutorial erstellt haben. Der `output-template-file` gibt den Namen der neuen Datei an, die vom AWS **sam deploy** SAM-Befehl verwendet wird.

# Stellen Sie die AWS SAM-Anwendung bereit
<a name="tutorial-lambda-sam-deploy"></a>

 Verwenden Sie den AWS **sam deploy** SAM-Befehl mit der `package.yml` Datei, um Ihre Lambda-Funktionen sowie Ihre CodeDeploy Anwendungs- und Bereitstellungsgruppe mithilfe von CloudFormation zu erstellen. 

**Anmerkung**  
Weitere Informationen zu diesem **sam deploy** Befehl finden Sie in der [AWS SAM CLI-Befehlsreferenz](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) im *AWS Serverless Application Model Entwicklerhandbuch*. 

 Führen Sie folgenden Befehl im `SAM-Tutorial`-Verzeichnis aus. 

```
sam deploy \
  --template-file package.yml \
  --stack-name my-date-time-app \
  --capabilities CAPABILITY_IAM
```

 Der `--capabilities CAPABILITY_IAM` Parameter ist erforderlich, um die Erstellung von CloudFormation IAM-Rollen zu autorisieren. 

# (Optional) inspizieren und testen Sie Ihre Infrastruktur
<a name="tutorial-lambda-sam-confirm-components"></a>

 In diesem Thema wird gezeigt, wie Sie Ihre Infrastrukturkomponenten anzeigen und Ihre Lambda-Funktion testen können. 

**So zeigen Sie das Ergebnis Ihres Stacks an, nachdem Sie `sam deploy` ausgeführt haben**

1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1.  Klicken Sie im Navigationsbereich auf **Stacks**. Der `my-date-time-app`-Stack wird oben angezeigt. 

1.  Wählen Sie die Registerkarte **Events (Ereignisse)** aus, um zu sehen, welche Ereignisse abgeschlossen sind. Sie können die Ereignisse während der Stack-Erstellung anzeigen. Wenn die Erstellung des Stacks abgeschlossen ist, werden alle Stack-Erstellungsereignisse angezeigt. 

1.  Klicken Sie bei ausgewähltem Stack auf **Resources (Ressourcen)**. In der Spalte **Typ** können Sie Ihre Lambda-Funktionen, `myDateTimeFunction``CodeDeployHook_beforeAllowTraffic`, und `CodeDeployHook_afterAllowTraffic` sehen. Die Spalte **Physikalische ID** jeder Ihrer Lambda-Funktionen enthält einen Link zum Anzeigen der Funktionen in der Lambda-Konsole. 
**Anmerkung**  
 Dem Namen der `myDateTimeFunction` Lambda-Funktion wird der Name des CloudFormation Stacks vorangestellt und es wird ein Bezeichner hinzugefügt, also sieht es so aus. `my-date-time-app-myDateTimeFunction-123456ABCDEF` 

1. Öffnen Sie die Konsole unter CodeDeploy . [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/)

1.  Erweitern Sie im Navigationsbereich **Deploy (Bereitstellen)** und klicken Sie danach auf **Applications (Anwendungen)**. 

1.  Sie sollten eine neue CodeDeploy Anwendung sehen, die von CloudFormation erstellt wurde und deren Name mit beginnt`my-date-time-app-ServerlessDeploymentApplication`. Wählen Sie diese Anwendung aus. 

1.  Sie sollten eine Bereitstellungsgruppe mit einem Namen sehen, der mit `my-date-time-app-myDateTimeFunctionDeploymentGroup` beginnt. Wählen Sie diese Bereitstellungsgruppe aus. 

    Unter **Bereitstellungskonfiguration** sollte Folgendes angezeigt werden **CodeDeployDefault. LambdaLinear10 PercentEvery 1 Minute.** 

**(Optional), um Ihre Funktion zu testen (Konsole)**

1. Öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  Wählen Sie im Navigationsbereich Ihre `my-date-time-app-myDateTimeFunction`-Funktion aus. In der Konsole enthält der Name eine Kennung, sodass er wie `my-date-time-app-myDateTimeFunction-123456ABCDEF` aussieht. 

1.  Wählen Sie **Test** aus. 

1.  Geben Sie unter **Event name (Ereignisname)** einen Namen für Ihr Testereignis ein. 

1.  Geben Sie Folgendes für Ihr Testereignis ein und wählen Sie dann **Create (Erstellen)** aus. 

   ```
   {
     "option": "date",
     "period": "today"
   }
   ```

1.  Wählen Sie **Test** aus. Sie sollten nur Ihr Testereignis in der Liste der Testereignisse sehen. 

    Für **Execution result (Ausführungsergebnis)** sollten Sie **erfolgreich** sehen. 

1.  Erweitern Sie unter **Execution result (Ausführungsergebnis)** die Option **Details**, um die Ergebnisse anzuzeigen. Sie sollten den aktuellen Monat, Tag und das Jahr sehen. 

**(Optional), um Ihre Funktion zu testen (AWS CLI)**

1.  Suchen Sie den ARN Ihrer Lambda-Funktion. Es wird oben in der Lambda-Konsole angezeigt, wenn Sie Ihre Funktion aufrufen. 

1.  Führen Sie den folgenden Befehl aus. *your-function-arn*Ersetzen Sie durch die Funktion ARN. 

   ```
   aws lambda invoke \
   --function your-function-arn \
   --cli-binary-format raw-in-base64-out \
   --payload "{\"option\": \"date\", \"period\": \"today\"}" out.txt
   ```

1.  Öffnen Sie `out.txt`, um sicherzustellen, dass das Ergebnis den aktuellen Monat, Tag und das Jahr enthält. 

# Schritt 2: Aktualisieren Sie die Lambda-Funktion
<a name="tutorial-lambda-sam-update-function"></a>

 In diesem Thema aktualisieren Sie Ihre `myDateTimeFunction.js`-Datei. Im nächsten Schritt verwenden Sie die Datei, um die aktualisierte Funktion bereitzustellen. Dies löst CodeDeploy die Bereitstellung aus, indem der Produktionsdatenverkehr von der aktuellen Version der Lambda-Funktion auf die aktualisierte Version verlagert wird. 

**Um Ihre Lambda-Funktion zu aktualisieren**

1.  Öffnen Sie `myDateTimeFunction.js`. 

1.  Entfernen Sie die beiden Kommentarmarkierungen ("`/*`" und "`*/`") und den Erläuterungstext am Anfang und am Ende des `case` mit dem Namen `time` im `switch`-Block. 

    Mit dem nicht kommentierten Code können Sie einen neuen Parameter, `time`, an die Funktion übergeben. Wenn Sie `time` an die aktualisierte Funktion übergeben, wird die aktuelle `hour`, `minute` und `second` zurückgegeben. 

1.  Speichern `myDateTimeFunction.js`. Sie sollte wie folgt aussehen: 

   ```
   'use strict';
   
   exports.handler = function(event, context, callback) {
   
     if (event.body) {
       event = JSON.parse(event.body);
     }
   
     var sc; // Status code
     var result = ""; // Response payload
   
     switch(event.option) {
       case "date":
         switch(event.period) {
           case "yesterday":
             result = setDateResult("yesterday");
             sc = 200;
             break;
           case "today":
             result = setDateResult();
             sc = 200;
             break;
           case "tomorrow":
             result = setDateResult("tomorrow");
             sc = 200;
             break;
           default:
             result = {
               "error": "Must specify 'yesterday', 'today', or 'tomorrow'."
             };
             sc = 400;
             break;
         }
         break;
         case "time":
           var d = new Date();
           var h = d.getHours();
           var mi = d.getMinutes();
           var s = d.getSeconds();
   
           result = {
             "hour": h,
             "minute": mi,
             "second": s
           };
           sc = 200;
           break;
   
         default:
           result = {
             "error": "Must specify 'date' or 'time'."
           };
           sc = 400;
         break;
     }
   
     const response = {
       statusCode: sc,
       headers: { "Content-type": "application/json" },
       body: JSON.stringify( result )
     };
   
     callback(null, response);
   
     function setDateResult(option) {
   
       var d = new Date(); // Today
       var mo; // Month
       var da; // Day
       var y; // Year
   
       switch(option) {
         case "yesterday":
           d.setDate(d.getDate() - 1);
           break;
         case "tomorrow":
           d.setDate(d.getDate() + 1);
         default:
          break;
       }
   
       mo = d.getMonth() + 1; // Months are zero offset (0-11)
       da = d.getDate();
       y = d.getFullYear();
   
       result = {
         "month": mo,
         "day": da,
         "year": y
       };
   
       return result;
     }
   };
   ```

# Schritt 3: Stellen Sie die aktualisierte Lambda-Funktion bereit
<a name="tutorial-lambda-sam-deploy-update"></a>

 In diesem Schritt verwenden Sie Ihr Update, `myDateTimeFunction.js` um Ihre Lambda-Funktion zu aktualisieren und deren Bereitstellung zu initiieren. Sie können den Bereitstellungsfortschritt in der CodeDeploy AWS Lambda OR-Konsole überwachen. 

 Die `AutoPublishAlias: live` Zeile in Ihrer AWS SAM Vorlage veranlasst Ihre Infrastruktur, Aktualisierungen von Funktionen zu erkennen, die den `live` Alias verwenden. Ein Update Ihrer Funktion löst eine Bereitstellung aus CodeDeploy , indem der Produktionsdatenverkehr von der ursprünglichen Version der Funktion auf die aktualisierte Version verlagert wird. 

 Die **sam deploy** Befehle **sam package** und werden verwendet, um die Bereitstellung Ihrer Lambda-Funktion zu aktualisieren und auszulösen. Sie haben diese Befehle in [Die AWS SAM-Anwendung verpacken](tutorial-lambda-sam-package.md) und [Stellen Sie die AWS SAM-Anwendung bereit](tutorial-lambda-sam-deploy.md) ausgeführt. 

**So stellen Sie Ihre aktualisierte Lambda-Funktion bereit**

1.  Führen Sie folgenden Befehl im `SAM-Tutorial`-Verzeichnis aus. 

   ```
   sam package \
     --template-file template.yml \
     --output-template-file package.yml  \
     --s3-bucket amzn-s3-demo-bucket
   ```

    Dadurch wird ein neuer Satz von Artefakten erstellt, die auf Ihre aktualisierte Lambda-Funktion in Ihrem S3-Bucket verweisen. 

1.  Führen Sie folgenden Befehl im `SAM-Tutorial`-Verzeichnis aus. 

   ```
   sam deploy \
     --template-file package.yml \
     --stack-name my-date-time-app \
     --capabilities CAPABILITY_IAM
   ```

   Da der Stack-Name immer noch lautet, wird CloudFormation erkannt`my-date-time-app`, dass es sich um ein Stack-Update handelt. Um Ihren aktualisierten Stack anzuzeigen, kehren Sie zur CloudFormation Konsole zurück und wählen Sie im Navigationsbereich **Stacks** aus.

**(Optional), um den Datenverkehr während einer Bereitstellung anzuzeigen (CodeDeploy Konsole)**

1. Öffnen Sie die CodeDeploy Konsole unter [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).

1.  Erweitern Sie im Navigationsbereich **Anwendungen**, und wählen Sie dann Ihre **my-date-time-appServerlessDeploymentApplicationAnwendung** aus. 

1.  Wählen Sie unter **Deployment groups (Bereitstellungsgruppen)** die Bereitstellungsgruppe Ihrer Anwendung aus. Der Status sollte **In progress (In Bearbeitung)** sein. 

1.  Wählen Sie unter **Deployment group history (Bereitstellungsgruppenverlauf)** die Bereitstellung aus, die gerade ausgeführt wird. 

   Die Fortschrittsanzeige **Traffic Shifting (Verschiebung von Datenverkehr)** und die Prozentsätze in den Feldern **Original** und **Ersatz** auf dieser Seite zeigen ihren Fortschritt an.   
![\[Der Fortschrittsbereich für die Verkehrsverlagerung in der CodeDeploy Konsole.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/lambda-tutorial-codedeploy-console-20-percent-deployed.png)

**(Optional) zur Anzeige des Datenverkehrs während einer Bereitstellung (Lambda-Konsole)**

1. Öffnen Sie die AWS Lambda Konsole unter. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)

1.  Wählen Sie im Navigationsbereich Ihre `my-date-time-app-myDateTimeFunction`-Funktion aus. In der Konsole enthält der Name eine Kennung, sodass er wie `my-date-time-app-myDateTimeFunction-123456ABCDEF` aussieht. 

1.  Wählen Sie **Aliase** und dann **Live** aus. 

Die Gewichtungen neben Ihrer ursprünglichen Funktionsversion (Version 1) und Ihrer aktualisierten Funktionsversion (Version 2) zeigen an, wie viel Datenverkehr an jede Version zum Zeitpunkt des Ladens dieser AWS Lambda -Konsolenseite geleitet wird. Die Seite aktualisiert die Gewichtungen nicht im Laufe der Zeit. Wenn Sie die Seite einmal pro Minute aktualisieren, verringert sich die Gewichtung für Version 1 um 10 Prozent und die Gewichtung für Version 2 erhöht sich um 10 Prozent, bis die Gewichtung für Version 2 100 beträgt. 

![\[Der Aliasbereich der CodeDeploy Konsole.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/lambda-tutorial-lambda-console-20-percent-deployed.png)


# Schritt 4: Zeigen Sie Ihre Bereitstellungsergebnisse an
<a name="tutorial-lambda-sam-deploy-view-results"></a>

In diesem Schritt zeigen Sie die Ergebnisse Ihrer Bereitstellung an. Wenn Ihre Bereitstellung erfolgreich ist, können Sie bestätigen, dass Ihre aktualisierte Lambda-Funktion Produktionsdatenverkehr empfängt. Wenn Ihre Bereitstellung fehlschlägt, können Sie mithilfe von CloudWatch Logs die Ergebnisse der Validierungstests in der Lambda-Funktion anzeigen, die während der Lifecycle-Hooks Ihrer Bereitstellung ausgeführt werden. 

**Topics**
+ [Testen Sie Ihre bereitgestellte Funktion](#tutorial-lambda-sam-deploy-test-deployed-function)
+ [Hook-Ereignisse in CloudWatch Logs anzeigen](#tutorial-lambda-view-hook-events)

## Testen Sie Ihre bereitgestellte Funktion
<a name="tutorial-lambda-sam-deploy-test-deployed-function"></a>

 Der **sam deploy** Befehl aktualisiert die `my-date-time-app-myDateTimeFunction` Lambda-Funktion. Die Funktionsversion wird auf 2 aktualisiert und dem `live`-Alias hinzugefügt. 

**Um das Update in der Lambda-Konsole zu sehen**

1. Öffnen Sie die AWS Lambda Konsole unter. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)

1.  Wählen Sie im Navigationsbereich die `my-date-time-app-myDateTimeFunction`-Funktion aus. In der Konsole enthält der Name eine Kennung, sodass er wie `my-date-time-app-myDateTimeFunction-123456ABCDEF` aussieht. 

1.  Wählen Sie **Qualifiers (Qualifizierer)** und dann **Aliases (Aliasse)** aus. Nachdem die Bereitstellung abgeschlossen ist (ca. 10 Minuten), sollte für den `live`-Alias **Version: 2** angezeigt werden.  
![\[Der Aliasbereich der CodeDeploy Konsole.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/lambda-tutorial-function-version.png)

1.  Unter **Function code (Funktionscode)** können Sie den Quellcode für Ihre Funktion anzeigen. Ihre Änderungen sollten angezeigt werden. 

1.  (Optional) Sie können die Testanweisungen in [Schritt 2: Aktualisieren Sie die Lambda-Funktion](tutorial-lambda-sam-update-function.md) verwenden, um Ihre aktualisierte Funktion zu testen. Erstellen Sie ein neues Testereignis mit der folgenden Nutzlast und stellen Sie sicher, dass das Ergebnis die aktuelle Stunde, Minute und Sekunde enthält. 

   ```
   {
       "option": "time"
     }
   ```

    Um die aktualisierte Funktion AWS CLI zu testen, führen Sie den folgenden Befehl aus und öffnen Sie ihn, `out.txt` um zu bestätigen, dass das Ergebnis die aktuelle Stunde, Minute und Sekunde enthält. 

   ```
   aws lambda invoke --function your-function-arn --payload "{\"option\": \"time\"}" out.txt 
   ```
**Anmerkung**  
 Wenn Sie den verwenden AWS CLI , um Ihre Funktion zu testen, bevor die Bereitstellung abgeschlossen ist, erhalten Sie möglicherweise unerwartete Ergebnisse. Das liegt daran, dass jede Minute 10 Prozent des Datenverkehrs CodeDeploy schrittweise auf die aktualisierte Version umgestellt werden. Während der Bereitstellung zeigt der Datenverkehr weiterhin auf die ursprüngliche Version, sodass `aws lambda invoke` möglicherweise die Originalversion verwendet. Nach 10 Minuten ist die Bereitstellung abgeschlossen und der gesamte Datenverkehr zeigt auf die neue Version der Funktion. 

## Hook-Ereignisse in CloudWatch Logs anzeigen
<a name="tutorial-lambda-view-hook-events"></a>

 CodeDeploy Führt während des `BeforeAllowTraffic` Hooks Ihre `CodeDeployHook_beforeAllowTraffic` Lambda-Funktion aus. CodeDeploy Führt während des `AfterAllowTraffic` Hooks Ihre `CodeDeployHook_afterAllowTraffic` Lambda-Funktion aus. Jede Funktion führt einen Validierungstest aus, der die aktualisierte Version Ihrer Funktion mit dem neuen `time`-Parameter aufruft. Wenn das Update Ihrer Lambda-Funktion erfolgreich ist, verursacht die `time` Option keinen Fehler und die Validierung ist erfolgreich. Wenn die Funktion nicht aktualisiert wurde, führt der nicht erkannte Parameter zu einem Fehler und die Validierung schlägt fehl. Diese Validierungstests dienen nur zu Demonstrationszwecken. Sie schreiben eigene Tests, um Ihre Bereitstellung zu validieren. Sie können die CloudWatch Logs-Konsole verwenden, um Ihre Validierungstests anzusehen. 

**Um Ihre CodeDeploy Hook-Ereignisse einzusehen**

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1.  Wählen Sie im Navigationsbereich **Logs (Protokolle)** aus. 

1.  Wählen Sie in der Liste der Protokollgruppen**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic** oder**/aws/lambda/CodeDeployHook\$1** ausafterAllowTraffic. 

1.  Wählen Sie den Protokollstream. Sie sollten nur eine sehen. 

1.  Erweitern Sie die Ereignisse, um ihre Details anzuzeigen.   
![\[Der Protokollstream einer CodeDeployHook Protokollgruppe.\]](http://docs.aws.amazon.com/de_de/codedeploy/latest/userguide/images/lambda-tutorial-cloudwatch.png)

# Schritt 5: Bereinigen
<a name="tutorial-lambda-clean-up"></a>

Um weitere Gebühren für Ressourcen zu vermeiden, die Sie in diesem Tutorial verwendet haben, löschen Sie die von Ihrer AWS SAM Vorlage erstellten Ressourcen und die von Ihren Lambda-Validierungsfunktionen erstellten CloudWatch Protokolle.

**Um Ihren Stack zu löschen CloudFormation**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Wählen Sie in der Spalte **Stacks** Ihren `my-date-time-app`-Stack aus und klicken Sie dann auf **Löschen**.

1. Wählen Sie bei Aufforderung **Delete stack (Stack löschen)** aus. Die Lambda-Funktionen, die CodeDeploy Anwendungs- und Bereitstellungsgruppe sowie die IAM-Rollen, die von erstellt wurden, AWS SAM werden gelöscht.

**Um Ihre Logs in Logs zu löschen CloudWatch**

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1.  Wählen Sie im Navigationsbereich **Logs (Protokolle)** aus. 

1.  Wählen Sie in der Liste der Protokollgruppen die Schaltfläche neben**/aws/lambda/CodeDeployHook\$1** ausbeforeAllowTraffic. 

1.  Wählen Sie unter **Actions (Aktionen)** die Option **Delete log group (Protokollgruppe löschen)** und dann **Yes, Delete (Ja, löschen)** aus. 

1.  Wählen Sie in der Liste der Protokollgruppen die Schaltfläche neben**/aws/lambda/CodeDeployHook\$1** ausafterAllowTraffic. 

1.  Wählen Sie unter **Actions (Aktionen)** die Option **Delete log group (Protokollgruppe löschen)** und dann **Yes, Delete (Ja, löschen)** aus.