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: Bereitstellen eines Amazon ECS-Service mit einem Validierungstest
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
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
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
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
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
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
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
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
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
```