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.
# Tutorial: Wird verwendet CodeDeploy , um eine Anwendung für eine Auto Scaling Scaling-Gruppe bereitzustellen
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
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
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)
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)
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
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)
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)
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
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)
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)
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
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
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
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
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)
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)
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
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):
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):
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.