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.

# Tutorials für Amazon ECS
<a name="ecs-tutorials"></a>

Die folgenden Tutorials veranschaulichen, wie Sie mit Amazon ECS gängige Aufgaben durchführen.

Sie können jedes der folgenden Tutorials verwenden, um mehr über die ersten Schritte mit Amazon ECS zu erfahren.


| Tutorial-Übersicht | Weitere Informationen | 
| --- | --- | 
|  Erste Schritte mit Amazon ECS in Fargate.  |  [Erfahren Sie, wie Sie eine Amazon-ECS-Linux-Aufgabe für Fargate erstellen.](getting-started-fargate.md)  | 
|  Erste Schritte mit Windows-Containern in Fargate.  |  [Erfahren Sie, wie Sie eine Amazon-ECS-Windows-Aufgabe für Fargate erstellen.](Windows_fargate-getting_started.md)  | 
|  Erste Schritte mit Windows-Containern für EC2.  |  [Erfahren Sie, wie Sie eine Amazon-ECS-Windows-Aufgabe für EC2 erstellen.](getting-started-ecs-ec2-v2.md)  | 

Sie können jedes der folgenden Tutorials verwenden, um Aufgaben auf Amazon ECS bereitzustellen, indem Sie AWS CLI


| Tutorial-Übersicht | Weitere Informationen | 
| --- | --- | 
|  Erstellen Sie eine Linux-Aufgabe für Fargate.  |  [Erstellen einer Amazon ECS-Linux-Aufgabe für den Fargate mit dem AWS CLI](ECS_AWSCLI_Fargate.md)  | 
|  Erstellen Sie eine Windows-Aufgabe für Fargate.  |  [Erstellen einer Amazon ECS-Windows-Aufgabe für den Fargate mit dem AWS CLI](ECS_AWSCLI_Fargate_windows.md)  | 
|  Erstellen Sie eine Linux-Aufgabe für EC2.  |  [Erstellen einer Amazon ECS-Aufgabe für EC2 mit dem AWS CLI](ECS_AWSCLI_EC2.md)  | 

Sie können jedes der folgenden Tutorials verwenden, um mehr über Überwachung und Protokollierung zu erfahren.


| Tutorial-Übersicht | Weitere Informationen | 
| --- | --- | 
|  Richten Sie eine einfache Lambda-Funktion ein, die auf Aufgabenereignisse wartet und diese in einen CloudWatch Log-Log-Stream schreibt.  |  [Konfiguration von Amazon ECS für die Überwachung von CloudWatch Ereignissen](ecs_cwet.md)  | 
|  Konfigurieren Sie eine EventBridge Amazon-Ereignisregel, die nur Aufgabenereignisse erfasst, bei denen die Ausführung der Aufgabe beendet wurde, weil einer ihrer wichtigsten Container beendet wurde.   |  [Senden von Warnungen von Amazon Simple Notification Service bei angehaltenen Amazon-ECS-Aufgaben](ecs_cwet2.md)  | 
|  Verketten Sie Protokollnachrichten, die ursprünglich zu einem Kontext gehören, aber auf mehrere Datensätze oder Protokollzeilen aufgeteilt wurden.  |  [Verketten mehrzeiliger oder Stack-Trace-Protokollnachrichten in Amazon ECS](firelens-concatanate-multiline.md)  | 
|  Stellen Sie Fluent Bit-Container auf ihren Windows-Instances bereit, die in Amazon ECS ausgeführt werden, um die von den Windows-Aufgaben generierten Protokolle CloudWatch zur zentralen Protokollierung an Amazon zu streamen.  |  [Bereitstellen von Fluent Bit in Amazon-ECS-Windows-Containers](tutorial-deploy-fluentbit-on-windows.md)  | 

Sie können jedes der folgenden Tutorials verwenden, um mehr über die Verwendung der Active-Directory-Authentifizierung mit einem Group Managed Service Account in Amazon ECS zu erfahren.


| Tutorial-Übersicht | Weitere Informationen | 
| --- | --- | 
|  Verwenden Sie das group Managed Service Account mit Linux-Containern in EC2.  |  [Verwendung von gMSA für EC2-Linux-Container in Amazon ECS](linux-gmsa.md)  | 
|  Verwenden Sie das group Managed Service Account mit Windows-Containern in EC2.  |  [Erfahren Sie, wie Sie gMSAs für EC2-Windows-Containers für Amazon ECS verwenden.](windows-gmsa.md)  | 
|  Verwenden Sie das group Managed Service Account mit Linux-Containern in Fargate.  |  [Verwendung von gMSA für Linux-Container in Fargate](fargate-linux-gmsa.md)  | 
|  Erstellen Sie eine Aufgabe, die einen Windows-Container ausführt, der über Anmeldeinformationen für den Zugriff auf Active Directory mit einem domainnenlosen group Managed Service Account verfügt.  |  [Verwenden von Amazon ECS-Windows-Containern mit domainless unter gMSA Verwendung von AWS CLI](tutorial-gmsa-windows.md)  | 

# Erstellen einer Amazon ECS-Linux-Aufgabe für den Fargate mit dem AWS CLI
<a name="ECS_AWSCLI_Fargate"></a>

Mithilfe der folgenden Schritte können Sie über die AWS CLI einen Cluster einrichten, eine Aufgabendefinition registrieren, eine Linux-Aufgabe ausführen sowie andere allgemeine Szenarien in Amazon ECS umsetzen. Verwenden Sie die neuesten Version der AWS CLI. Weitere Informationen zur Aktualisierung auf die neueste Version finden Sie unter [Installieren oder Aktualisieren auf die neueste Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**Anmerkung**  
Sie können Dual-Stack-Service-Endpunkte verwenden, um mit Amazon ECS über die AWS CLI SDKs, und die Amazon ECS-API sowohl über als auch IPv4 zu interagieren. IPv6 Weitere Informationen finden Sie unter [Verwenden von Dual-Stack-Endpunkten in Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [Voraussetzungen](#ECS_AWSCLI_Fargate_prereq)
+ [Schritt 1: Erstellen eines Clusters](#ECS_AWSCLI_Fargate_create_cluster)
+ [Schritt 2: Anmelden einer Linux-Aufgabendefinition](#ECS_AWSCLI_Fargate_register_task_definition)
+ [Schritt 3: Auflisten der Aufgabendefinitionen](#ECS_AWSCLI_Fargate_list_task_definitions)
+ [Schritt 4: Einen Service erstellen](#ECS_AWSCLI_Fargate_create_service)
+ [Schritt 5: Auflisten von Services](#ECS_AWSCLI_Fargate_list_services)
+ [Schritt 6: Beschreibung des gerade ausgeführten Service](#ECS_AWSCLI_Fargate_describe_service)
+ [Schritt 7: Testen](#ECS_AWSCLI_Fargate_test)
+ [Schritt 8: Bereinigen](#ECS_AWSCLI_Fargate_clean_up)

## Voraussetzungen
<a name="ECS_AWSCLI_Fargate_prereq"></a>

In diesem Tutorial wird davon ausgegangen, dass die folgenden Voraussetzungen erfüllt wurden:
+ Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen zur Installation oder Aktualisierung Ihres AWS CLI finden Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
+ Sie haben eine VPC und die zu verwendende Sicherheitsgruppe erstellt. In diesem Tutorial wird ein Container-Image verwendet, das auf Amazon ECR Public gehostet wird, sodass Ihre Aufgabe über Internetzugang verfügen muss. Um Ihrer Aufgabe eine Route zum Internet zu geben, verwenden Sie eine der folgenden Optionen.
  + Verwenden Sie ein privates Subnetz mit einem NAT-Gateway, das über eine Elastic IP-Adresse verfügt.
  + Verwenden Sie ein öffentliches Subnetz und weisen Sie der Aufgabe eine öffentliche IP-Adresse zu.

  Weitere Informationen finden Sie unter [Erstellen einer Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Informationen zu Sicherheitsgruppen und Regeln finden Sie unter [Standardsicherheitsgruppen für Sie VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) und [Beispielregeln](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) im *Amazon Virtual Private Cloud Cloud-Benutzerhandbuch*.
+  Wenn Sie diesem Tutorial mit einem privaten Subnetz folgen, können Sie Amazon ECS Exec verwenden, um direkt mit Ihrem Container zu interagieren und die Bereitstellung zu testen. Sie müssen eine Aufgaben-IAM-Rolle erstellen, um ECS Exec verwenden zu können. Weitere Informationen zur Aufgaben-IAM-Rolle und zu anderen Voraussetzungen finden Sie unter [Überwachen von Amazon-ECS-Containern mit Amazon ECS Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html).
+ (Optional) AWS CloudShell ist ein Tool, das Kunden eine Befehlszeile bietet, ohne dass sie ihre eigene EC2-Instance erstellen müssen. Weitere Informationen finden Sie unter [Was ist? AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) im *AWS CloudShell Benutzerhandbuch*.

## Schritt 1: Erstellen eines Clusters
<a name="ECS_AWSCLI_Fargate_create_cluster"></a>

Ihr Konto erhält standardmäßig ein `default` Cluster.

**Anmerkung**  
Wenn Sie den bereitgestellten Cluster `default` verwenden, hat dies den Vorteil, dass Sie in den nachfolgenden Befehlen nicht die Option `--cluster cluster_name` angeben müssen. Wenn Sie Ihren eigenen, nicht standardmäßigen Cluster erstellen, müssen Sie `--cluster cluster_name` für jeden Befehl angeben, den Sie mit diesem Cluster verwenden möchten.

Erstellen Sie mit dem folgenden Befehl Ihren eigenen Cluster mit eindeutigem Namen:

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Ausgabe:

```
{
    "cluster": {
        "status": "ACTIVE", 
        "defaultCapacityProviderStrategy": [], 
        "statistics": [], 
        "capacityProviders": [], 
        "tags": [], 
        "clusterName": "fargate-cluster", 
        "settings": [
            {
                "name": "containerInsights", 
                "value": "disabled"
            }
        ], 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Schritt 2: Anmelden einer Linux-Aufgabendefinition
<a name="ECS_AWSCLI_Fargate_register_task_definition"></a>

Bevor Sie auf Ihrem ECS-Cluster eine Aufgabe ausführen können, müssen Sie eine Aufgabendefinition registrieren. Aufgabendefinitionen sind Listen zusammengefasster Container. Das folgende Beispiel ist eine einfache Aufgabendefinition, die eine PHP-Web-App mit dem httpd-Container-Image erstellt, das auf Docker Hub gehostet wird. Weitere Informationen zu den verfügbaren Parametern für die Aufgabendefinition finden Sie im Abschnitt [Amazon-ECS-Aufgabendefinitionen](task_definitions.md). Für dieses Tutorial wird `taskRoleArn` nur benötigt, wenn Sie die Aufgabe in einem privaten Subnetz bereitstellen und die Bereitstellung testen möchten. Ersetzen Sie `taskRoleArn` die durch die IAM-Aufgabenrolle, die Sie für die Verwendung von ECS Exec erstellt haben, wie unter [Voraussetzungen](#ECS_AWSCLI_Fargate_prereq) beschrieben.

```
 {
        "family": "sample-fargate",
        "networkMode": "awsvpc",
        "taskRoleArn": "arn:aws:iam::aws_account_id:role/execCommandRole", 
        "containerDefinitions": [
            {
                "name": "fargate-app",
                "image": "public.ecr.aws/docker/library/httpd:latest",
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "essential": true,
                "entryPoint": [
                    "sh",
                    "-c"
                ],
                "command": [
                    "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
                ]
            }
        ],
        "requiresCompatibilities": [
            "FARGATE"
        ],
        "cpu": "256",
        "memory": "512"
}
```

Speichern Sie die JSON-Datei der Aufgabendefinition als Datei und übergeben Sie sie zusammen mit der `--cli-input-json file://path_to_file.json`-Option. 

Verwendung einer JSON-Datei für Containerdefinitionen:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

Der Befehl **register-task-definition** gibt nach Abschluss der Registrierung eine Beschreibung der Aufgabendefinition zurück.

## Schritt 3: Auflisten der Aufgabendefinitionen
<a name="ECS_AWSCLI_Fargate_list_task_definitions"></a>

Sie können die Aufgabendefinitionen für Ihr Konto jederzeit mit dem Befehl **list-task-definitions** auflisten. In der Ausgabe dieses Befehls werden die Werte `family` und `revision` angezeigt, die Sie beim Aufruf von **run-task** oder **start-task** gemeinsam verwenden können.

```
aws ecs list-task-definitions
```

Ausgabe:

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
    ]
}
```

## Schritt 4: Einen Service erstellen
<a name="ECS_AWSCLI_Fargate_create_service"></a>

Nachdem Sie eine Aufgabe für Ihr Konto registriert haben, können Sie einen Service für die registrierte Aufgabe in Ihrem Cluster erstellen. In diesem Beispiel erstellen Sie einen Service mit einer Instance der `sample-fargate:1`-Aufgabendefinition, die in Ihrem Cluster ausgeführt wird. Die Aufgabe erfordert eine Route zum Internet, daher gibt es zwei Möglichkeiten, dies zu erreichen. Eine Möglichkeit besteht darin, ein privates Subnetz zu verwenden, das mit einem NAT-Gateway mit einer Elastic IP-Adresse in einem öffentlichen Subnetz konfiguriert ist. Eine andere Möglichkeit besteht darin, ein öffentliches Subnetz zu verwenden und Ihrer Aufgabe eine öffentliche IP-Adresse zuzuweisen. Wir stellen beide Beispiele unten zur Verfügung. 

Beispiel mit einem privaten Subnetz. Die ` enable-execute-command `-Option ist erforderlich, um Amazon ECS Exec zu verwenden.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}" --enable-execute-command
```

Beispiel mit einem öffentlichen Subnetz.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

Der Befehl **create-service** gibt nach Abschluss der Registrierung eine Beschreibung der Aufgabendefinition zurück.

## Schritt 5: Auflisten von Services
<a name="ECS_AWSCLI_Fargate_list_services"></a>

Listet die Services für Ihren Cluster auf. Der im vorherigen Abschnitt erstellte Service müsste angezeigt werden. Sie können den Servicenamen oder den vollständigen ARN, die/der von diesem Befehl zurückgegeben wird, später zur Beschreibung des Service verwenden.

```
aws ecs list-services --cluster fargate-cluster
```

Ausgabe:

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-cluster/fargate-service"
    ]
}
```

## Schritt 6: Beschreibung des gerade ausgeführten Service
<a name="ECS_AWSCLI_Fargate_describe_service"></a>

Beschreibt Sie den Service unter Verwendung des zuvor abgerufenen Servicenamen, um weitere Informationen über die Aufgabe zu erhalten.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

Wenn dies erfolgreich ist, wird eine Beschreibung der Servicefehler und Services zurückgegeben. Im Abschnitt ` services ` finden Sie beispielsweise Informationen zu Bereitstellungen, z. B. ob Aufgaben den Status ausgeführt oder ausstehend haben. Möglicherweise finden Sie auch Informationen zur Aufgabendefinition, zur Netzwerkkonfiguration und zu Ereignissen mit Zeitstempeln. Im Abschnitt „Fehler“ finden Sie Informationen zu Fehlern (falls vorhanden), die mit dem Aufruf verbunden sind. Informationen zur Fehlerbehebung finden Sie unter [Service-Ereignismeldungen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Weitere Informationen zur Servicebeschreibung finden Sie unter [Beschreiben von Services](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices).

```
{
    "services": [
        {
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "ENABLED"
                }
            }, 
            "launchType": "FARGATE", 
            "enableECSManagedTags": false, 
            "loadBalancers": [], 
            "deploymentController": {
                "type": "ECS"
            }, 
            "desiredCount": 1, 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "createdAt": 1692283199.771, 
            "schedulingStrategy": "REPLICA", 
            "placementConstraints": [], 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "ENABLED"
                        }
                    }, 
                    "pendingCount": 0, 
                    "launchType": "FARGATE", 
                    "createdAt": 1692283199.771, 
                    "desiredCount": 1, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1", 
                    "updatedAt": 1692283199.771, 
                    "platformVersion": "1.4.0", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "serviceName": "fargate-service", 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "status": "ACTIVE", 
            "serviceRegistries": [], 
            "pendingCount": 0, 
            "createdBy": "arn:aws:iam::aws_account_id:user/user_name", 
            "platformVersion": "LATEST", 
            "placementStrategy": [], 
            "propagateTags": "NONE", 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
        }
    ], 
    "failures": []
}
```

## Schritt 7: Testen
<a name="ECS_AWSCLI_Fargate_test"></a>

### Die Testaufgabe wurde über ein öffentliches Subnetz bereitgestellt
<a name="ECS_AWSCLI_Fargate_test_public"></a>

Beschreiben Sie die Aufgabe im Service, damit Sie die Elastic-Network-Schnittstelle (ENI) für die Aufgabe abrufen können. 

Rufen Sie zunächst den ARN der Aufgabe ab.

```
aws ecs list-tasks --cluster fargate-cluster --service fargate-service
```

Die Ausgabe enthält den ARN der Aufgabe.

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
    ]
}
```

Beschreiben Sie die Aufgabe und suchen Sie die ENI-ID. Verwenden Sie den ARN der Aufgabe für den `tasks`-Parameter.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/service/EXAMPLE
```

Die Anhangsinformationen sind in der Ausgabe aufgeführt. 

```
{
    "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                    ]
                }
…
}
```

Beschreiben Sie die ENI, um die öffentliche IP-Adresse abzurufen.

```
aws ec2 describe-network-interfaces --network-interface-id  eni-0fa40520aeEXAMPLE
```

Die öffentliche IP-Adresse befindet sich in der Ausgabe. 

```
{
    "NetworkInterfaces": [
        {
            "Association": {
                "IpOwnerId": "amazon",
                "PublicDnsName": "ec2-34-229-42-222.compute-1.amazonaws.com",
                "PublicIp": "198.51.100.2"
            },
…
}
```

Geben Sie die öffentliche IP-Adresse in Ihren Webbrowser ein. Sie sehen eine Webseite, die die **Amazon-ECS**-Beispielsanwendung anzeigt.

### Die Testaufgabe wurde über ein privates Subnetz bereitgestellt
<a name="ECS_AWSCLI_Fargate_test_private.title"></a>

 Beschreiben Sie die Aufgabe und suchen Sie nach `managedAgents`, um zu überprüfen, ob der `ExecuteCommandAgent` ausgeführt wird. Notieren Sie sich die `privateIPv4Address` für die spätere Verwendung.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
```

 Die Informationen zum verwalteten Agenten werden in der Ausgabe aufgelistet. 

```
{
     "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                        {
                            "name": "privateIPv4Address",
                            "value": "10.0.143.156"
                        }
                    ]
                }
            ],
     ...  
     "containers": [
         {
         ...
        "managedAgents": [
                        {
                            "lastStartedAt": "2023-08-01T16:10:13.002000+00:00",
                            "name": "ExecuteCommandAgent",
                            "lastStatus": "RUNNING"
                        } 
                ],
        ...
    }
```

 Nachdem Sie sich vergewissert haben, dass ` ExecuteCommandAgent` ausgeführt wird, können Sie den folgenden Befehl ausführen, um eine interaktive Shell für den Container in der Aufgabe auszuführen. 

```
  aws ecs execute-command --cluster fargate-cluster \
      --task  arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE  \
      --container  fargate-app \
      --interactive \
      --command "/bin/sh"
```

 Nachdem die interaktive Shell ausgeführt wurde, führen Sie die folgenden Befehle aus, um cURL zu installieren. 

```
apt update 
```

```
apt install curl 
```

 Führen Sie nach der Installation von cURL den folgenden Befehl mit der privaten IP-Adresse aus, die Sie zuvor erhalten haben.

```
 curl 10.0.143.156 
```

 Sie sollten das HTML-Äquivalent der **Amazon-ECS**-Beispielanwendungs-Webseite sehen.

```
<html>
    <head> 
     <title>Amazon ECS Sample App</title> 
     <style>body {margin-top: 40px; background-color: #333;} </style>
    </head>
      <body> 
      <div style=color:white;text-align:center> 
      <h1>Amazon ECS Sample App</h1> 
      <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> 
      </div>
      </body>
</html>
```

## Schritt 8: Bereinigen
<a name="ECS_AWSCLI_Fargate_clean_up"></a>

Wenn Sie mit diesem Tutorial fertig sind, sollten Sie die zugehörigen Ressourcen bereinigen, um zu vermeiden, dass Gebühren für ungenutzte Ressourcen anfallen.

Löschen Sie den Service:

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Löschen Sie den Cluster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Erstellen einer Amazon ECS-Windows-Aufgabe für den Fargate mit dem AWS CLI
<a name="ECS_AWSCLI_Fargate_windows"></a>

Mithilfe der folgenden Schritte können Sie über die AWS CLI einen Cluster einrichten, eine Aufgabendefinition registrieren, eine Windows-Aufgabe ausführen sowie andere allgemeine Szenarien in Amazon ECS umsetzen. Vergewissern Sie sich, dass Sie die neueste Version der AWS CLI-CLI verwenden. Weitere Informationen zur Aktualisierung auf die neueste Version finden Sie unter [Installieren oder Aktualisieren auf die neueste Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**Anmerkung**  
Sie können Dual-Stack-Service-Endpunkte verwenden, um mit Amazon ECS über die AWS CLI SDKs, und die Amazon ECS-API sowohl über als auch IPv4 zu interagieren. IPv6 Weitere Informationen finden Sie unter [Verwenden von Dual-Stack-Endpunkten in Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [Voraussetzungen](#ECS_AWSCLI_Fargate_windows_prereq)
+ [Schritt 1: Erstellen eines Clusters](#ECS_AWSCLI_Fargate_windows_create_cluster)
+ [Schritt 2: Anmelden einer Windows-Aufgabendefinition](#ECS_AWSCLI_Fargate_windows_register_task_definition)
+ [Schritt 3: Auflisten der Aufgabendefinitionen](#ECS_AWSCLI_Fargate_windows__list_task_definitions)
+ [Schritt 4: Erstellen eines Services](#ECS_AWSCLI_Fargate_windows_create_service)
+ [Schritt 5: Auflisten von Services](#ECS_AWSCLI_Fargate_windows_list_services)
+ [Schritt 6: Beschreibung des gerade ausgeführten Service](#ECS_AWSCLI_Fargate_windows_describe_service)
+ [Schritt 7: Bereinigen](#ECS_AWSCLI_Fargate_windows_clean_up)

## Voraussetzungen
<a name="ECS_AWSCLI_Fargate_windows_prereq"></a>

In diesem Tutorial wird davon ausgegangen, dass die folgenden Voraussetzungen erfüllt wurden:
+ Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen zur Installation oder Aktualisierung von finden Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
+ Sie haben eine VPC und die zu verwendende Sicherheitsgruppe erstellt. In diesem Tutorial wird ein Container-Image verwendet, das auf Docker Hub gehostet wird, sodass Ihre Aufgabe über Internetzugang verfügen muss. Um Ihrer Aufgabe eine Route zum Internet zu geben, verwenden Sie eine der folgenden Optionen.
  + Verwenden Sie ein privates Subnetz mit einem NAT-Gateway, das über eine Elastic IP-Adresse verfügt.
  + Verwenden Sie ein öffentliches Subnetz und weisen Sie der Aufgabe eine öffentliche IP-Adresse zu.

  Weitere Informationen finden Sie unter [Erstellen einer Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Informationen zu Sicherheitsgruppen und Regeln finden Sie unter [Standardsicherheitsgruppen für Sie VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) und [Beispielregeln](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) im *Amazon Virtual Private Cloud Cloud-Benutzerhandbuch*.
+ (Optional) AWS CloudShell ist ein Tool, das Kunden eine Befehlszeile bietet, ohne dass sie ihre eigene EC2-Instance erstellen müssen. Weitere Informationen finden Sie unter [Was ist? AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) im *AWS CloudShell Benutzerhandbuch*.

## Schritt 1: Erstellen eines Clusters
<a name="ECS_AWSCLI_Fargate_windows_create_cluster"></a>

Ihr Konto erhält standardmäßig ein `default` Cluster.

**Anmerkung**  
Wenn Sie den bereitgestellten Cluster `default` verwenden, hat dies den Vorteil, dass Sie in den nachfolgenden Befehlen nicht die Option `--cluster cluster_name` angeben müssen. Wenn Sie Ihren eigenen, nicht standardmäßigen Cluster erstellen, müssen Sie `--cluster cluster_name` für jeden Befehl angeben, den Sie mit diesem Cluster verwenden möchten.

Erstellen Sie mit dem folgenden Befehl Ihren eigenen Cluster mit eindeutigem Namen:

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Ausgabe:

```
{
    "cluster": {
        "status": "ACTIVE", 
        "statistics": [], 
        "clusterName": "fargate-cluster", 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Schritt 2: Anmelden einer Windows-Aufgabendefinition
<a name="ECS_AWSCLI_Fargate_windows_register_task_definition"></a>

Bevor Sie auf Ihrem Amazon-ECS-Cluster eine Windows-Aufgabe ausführen können, müssen Sie eine Aufgabendefinition anmelden. Aufgabendefinitionen sind Listen zusammengefasster Container. Das folgende Beispiel ist eine einfache Aufgabendefinition, die eine Webanwendung erstellt. Weitere Informationen zu den verfügbaren Parametern für die Aufgabendefinition finden Sie im Abschnitt [Amazon-ECS-Aufgabendefinitionen](task_definitions.md).

```
{
    "containerDefinitions": [
        {
            "command": ["New-Item -Path C:\\inetpub\\wwwroot\\index.html -Type file -Value '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p>'; C:\\ServiceMonitor.exe w3svc"],
            "entryPoint": [
                "powershell",
                "-Command"
            ],
            "essential": true,
            "cpu": 2048,
            "memory": 4096,
            "image": "mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019",
            "name": "sample_windows_app",
            "portMappings": [
                {
                    "hostPort": 80,
                    "containerPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "memory": "4096",
    "cpu": "2048",
    "networkMode": "awsvpc",
    "family": "windows-simple-iis-2019-core",
    "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
    "runtimePlatform": {"operatingSystemFamily": "WINDOWS_SERVER_2019_CORE"},
    "requiresCompatibilities": ["FARGATE"]
}
```

Das obige Beispiel-JSON kann auf zwei Arten AWS CLI an die übergeben werden: Sie können die Aufgabendefinition JSON als Datei speichern und sie mit der `--cli-input-json file://path_to_file.json` Option übergeben.

Verwendung einer JSON-Datei für Containerdefinitionen:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

Der Befehl **register-task-definition** gibt nach Abschluss der Registrierung eine Beschreibung der Aufgabendefinition zurück.

## Schritt 3: Auflisten der Aufgabendefinitionen
<a name="ECS_AWSCLI_Fargate_windows__list_task_definitions"></a>

Sie können die Aufgabendefinitionen für Ihr Konto jederzeit mit dem Befehl **list-task-definitions** auflisten. In der Ausgabe dieses Befehls werden die Werte `family` und `revision` angezeigt, die Sie beim Aufruf von **run-task** oder **start-task** gemeinsam verwenden können.

```
aws ecs list-task-definitions
```

Ausgabe:

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1"
    ]
}
```

## Schritt 4: Erstellen eines Services
<a name="ECS_AWSCLI_Fargate_windows_create_service"></a>

Nachdem Sie eine Aufgabe für Ihr Konto registriert haben, können Sie einen Service für die registrierte Aufgabe in Ihrem Cluster erstellen. In diesem Beispiel erstellen Sie einen Service mit einer Instance der `sample-fargate:1`-Aufgabendefinition, die in Ihrem Cluster ausgeführt wird. Die Aufgabe erfordert eine Route zum Internet, daher gibt es zwei Möglichkeiten, dies zu erreichen. Eine Möglichkeit besteht darin, ein privates Subnetz zu verwenden, das mit einem NAT-Gateway mit einer Elastic IP-Adresse in einem öffentlichen Subnetz konfiguriert ist. Eine andere Möglichkeit besteht darin, ein öffentliches Subnetz zu verwenden und Ihrer Aufgabe eine öffentliche IP-Adresse zuzuweisen. Wir stellen beide Beispiele unten zur Verfügung. 

Beispiel mit einem privaten Subnetz.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}"
```

Beispiel mit einem öffentlichen Subnetz.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

Der Befehl **create-service** gibt nach Abschluss der Registrierung eine Beschreibung der Aufgabendefinition zurück.

## Schritt 5: Auflisten von Services
<a name="ECS_AWSCLI_Fargate_windows_list_services"></a>

Listet die Services für Ihren Cluster auf. Der im vorherigen Abschnitt erstellte Service müsste angezeigt werden. Sie können den Servicenamen oder den vollständigen ARN, die/der von diesem Befehl zurückgegeben wird, später zur Beschreibung des Service verwenden.

```
aws ecs list-services --cluster fargate-cluster
```

Ausgabe:

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-service"
    ]
}
```

## Schritt 6: Beschreibung des gerade ausgeführten Service
<a name="ECS_AWSCLI_Fargate_windows_describe_service"></a>

Beschreibt Sie den Service unter Verwendung des zuvor abgerufenen Servicenamen, um weitere Informationen über die Aufgabe zu erhalten.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

Wenn dies erfolgreich ist, wird eine Beschreibung der Servicefehler und Services zurückgegeben. Im Abschnitt „Services“ finden Sie beispielsweise Informationen zu Bereitstellungen, z. B. ob Aufgaben den Status ausgeführt oder ausstehend haben. Möglicherweise finden Sie auch Informationen zur Aufgabendefinition, zur Netzwerkkonfiguration und zu Ereignissen mit Zeitstempeln. Im Abschnitt „Fehler“ finden Sie Informationen zu Fehlern (falls vorhanden), die mit dem Aufruf verbunden sind. Informationen zur Fehlerbehebung finden Sie unter [Service-Ereignismeldungen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Weitere Informationen zur Servicebeschreibung finden Sie unter [Beschreiben von Services](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices). 

```
{
    "services": [
        {
            "status": "ACTIVE", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
            "pendingCount": 2, 
            "launchType": "FARGATE", 
            "loadBalancers": [], 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "placementConstraints": [], 
            "createdAt": 1510811361.128, 
            "desiredCount": 2, 
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "DISABLED"
                }
            }, 
            "platformVersion": "LATEST", 
            "serviceName": "fargate-service", 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "DISABLED"
                        }
                    }, 
                    "pendingCount": 2, 
                    "launchType": "FARGATE", 
                    "createdAt": 1510811361.128, 
                    "desiredCount": 2, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
                    "updatedAt": 1510811361.128, 
                    "platformVersion": "0.0.1", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "placementStrategy": []
        }
    ], 
    "failures": []
}
```

## Schritt 7: Bereinigen
<a name="ECS_AWSCLI_Fargate_windows_clean_up"></a>

Wenn Sie mit diesem Tutorial fertig sind, sollten Sie die zugehörigen Ressourcen bereinigen, um zu vermeiden, dass Gebühren für ungenutzte Ressourcen anfallen.

Löschen Sie den Service:

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Löschen Sie den Cluster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Erstellen einer Amazon ECS-Aufgabe für EC2 mit dem AWS CLI
<a name="ECS_AWSCLI_EC2"></a>

Mithilfe der folgenden Schritte können Sie über die AWS CLI einen Cluster einrichten, eine Aufgabendefinition registrieren, eine Aufgabe ausführen sowie andere allgemeine Szenarien in Amazon ECS umsetzen. Verwenden Sie die neuesten Version der AWS CLI. Weitere Informationen zur Aktualisierung auf die neueste Version finden Sie unter [Installieren oder Aktualisieren auf die neueste Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**Anmerkung**  
Sie können Dual-Stack-Service-Endpunkte verwenden, um mit Amazon ECS über die AWS CLI SDKs, und die Amazon ECS-API sowohl über als auch IPv4 zu interagieren. IPv6 Weitere Informationen finden Sie unter [Verwenden von Dual-Stack-Endpunkten in Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [Voraussetzungen](#AWSCLI_EC2_prereq)
+ [Erstellen eines Clusters](#AWSCLI_EC2_create_cluster)
+ [Starten einer Container-Instance mit dem Amazon-ECS-AMI](#AWSCLI_EC2_launch_container_instance)
+ [Container-Instances auflisten](#AWSCLI_EC2_list_container_instances)
+ [Die Container-Instance beschreiben](#AWSCLI_EC2_describe_container_instance)
+ [Eine Aufgabendefinition registrieren](#AWSCLI_EC2_register_task_definition)
+ [Aufgabendefinitionen auflisten](#AWSCLI_EC2_list_task_definitions)
+ [Einen Service erstellen](#AWSCLI_EC2_run_task)
+ [Services aufzählen](#AWSCLI_EC2_list_tasks)
+ [Den Service beschreiben](#AWSCLI_EC2_describe_service)
+ [Die ausgeführte Aufgabe beschreiben](#AWSCLI_EC2_describe_task)
+ [Den Webserver testen](#AWSCLI_EC2_test_web_server)
+ [Bereinigen von Ressourcen](#AWSCLI_EC2_clean_up_resources)

## Voraussetzungen
<a name="AWSCLI_EC2_prereq"></a>

In diesem Tutorial wird davon ausgegangen, dass die folgenden Voraussetzungen erfüllt wurden:
+ Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen zur Installation oder Aktualisierung von finden Sie unter [Installation oder Aktualisierung auf die neueste Version von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
+ Sie haben eine Container-Instance-IAM-Rolle zur Verwendung erstellt. Weitere Informationen finden Sie unter [IAM-Rolle für Amazon-ECS-Container-Instance](instance_IAM_role.md).
+ Sie haben eine VPC zur Verwendung erstellt. Weitere Informationen finden Sie unter [Erstellen einer Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ (Optional) AWS CloudShell ist ein Tool, das Kunden eine Befehlszeile bietet, ohne ihre eigene EC2-Instance erstellen zu müssen. Weitere Informationen finden Sie unter [Was ist? AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) im *AWS CloudShell Benutzerhandbuch*.

## Erstellen eines Clusters
<a name="AWSCLI_EC2_create_cluster"></a>

Standardmäßig erhält Ihr Konto beim Start Ihrer ersten Container-Instance einen Cluster `default`.

**Anmerkung**  
Wenn Sie den bereitgestellten Cluster `default` verwenden, hat dies den Vorteil, dass Sie in den nachfolgenden Befehlen nicht die Option `--cluster cluster_name` angeben müssen. Wenn Sie Ihren eigenen, nicht standardmäßigen Cluster erstellen, müssen Sie `--cluster cluster_name` für jeden Befehl angeben, den Sie mit diesem Cluster verwenden möchten.

Erstellen Sie mit dem folgenden Befehl Ihren eigenen Cluster mit eindeutigem Namen:

```
aws ecs create-cluster --cluster-name MyCluster
```

Ausgabe:

```
{
    "cluster": {
        "clusterName": "MyCluster",
        "status": "ACTIVE",
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/MyCluster"
    }
}
```

## Starten einer Container-Instance mit dem Amazon-ECS-AMI
<a name="AWSCLI_EC2_launch_container_instance"></a>

Container-Instances sind EC2-Instances, die den Amazon-ECS-Container-Agent ausführen und in einem Cluster registriert wurden. In diesem Abschnitt werden Sie mit dem ECS-optimierten AMI eine EC2-Instance starten.

**Um eine Container-Instance mit dem zu starten AWS CLI**

1. Rufen Sie mit dem folgenden AWS-Region Befehl die neueste ECS-optimierte Amazon Linux 2-AMI-ID für Sie ab. Dieser Befehl verwendet AWS Systems Manager Parameter Store, um die neueste ECS-optimierte AMI-ID abzurufen. Im AMI sind der Amazon-ECS-Container-Agent und die Docker-Laufzeit vorinstalliert.

   ```
   aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/recommended --query 'Parameters[0].Value' --output text | jq -r '.image_id'
   ```

   Ausgabe:

   ```
   ami-abcd1234
   ```

1. Erstellen Sie eine Sicherheitsgruppe, die SSH-Zugriff für die Verwaltung Ihrer Container-Instance und HTTP-Zugriff für den Webserver erlaubt.

   ```
   aws ec2 create-security-group --group-name ecs-tutorial-sg --description "ECS tutorial security group"
   ```

   Ausgabe:

   ```
   {
       "GroupId": "sg-abcd1234"
   }
   ```

1. Fügen Sie der Sicherheitsgruppe eine Regel für eingehenden Datenverkehr hinzu, indem Sie den folgenden Befehl ausführen.

   ```
   aws ec2 authorize-security-group-ingress --group-id sg-abcd1234 --protocol tcp --port 80 --cidr 0.0.0.0/0
   ```

   Ausgabe:

   ```
   {
       "Return": true,
       "SecurityGroupRules": [
           {
               "SecurityGroupRuleId": "sgr-efgh5678",
               "GroupId": "sg-abcd1234",
               "GroupOwnerId": "123456789012",
               "IsEgress": false,
               "IpProtocol": "tcp",
               "FromPort": 80,
               "ToPort": 80,
               "CidrIpv4": "0.0.0.0/0"
           }
       ]
   }
   ```

   Die Sicherheitsgruppe ermöglicht jetzt SSH-Zugriff aus dem angegebenen IP-Bereich und HTTP-Zugriff von überall. In einer Produktionsumgebung sollten Sie den SSH-Zugriff auf Ihre spezifische IP-Adresse beschränken und erwägen, den HTTP-Zugriff nach Bedarf einzuschränken.

1. Erstellen Sie ein EC2-Schlüsselpaar für den SSH-Zugriff auf die Container-Instance.

   ```
   aws ec2 create-key-pair --key-name ecs-tutorial-key --query 'KeyMaterial' --output text > ecs-tutorial-key.pem
   chmod 400 ecs-tutorial-key.pem
   ```

   Der private Schlüssel wird auf Ihrem lokalen Computer mit entsprechenden Berechtigungen für den SSH-Zugriff gespeichert.

1. Starten Sie eine EC2-Instance mit dem ECS-optimierten AMI und konfigurieren Sie sie so, dass sie Ihrem Cluster beitritt.

   ```
   aws ec2 run-instances --image-id ami-abcd1234 --instance-type t3.micro --key-name ecs-tutorial-key --security-group-ids sg-abcd1234 --iam-instance-profile Name=ecsInstanceRole --user-data '#!/bin/bash
   echo ECS_CLUSTER=MyCluster >> /etc/ecs/ecs.config'
   {
       "Instances": [
           {
               "InstanceId": "i-abcd1234",
               "ImageId": "ami-abcd1234",
               "State": {
                   "Code": 0,
                   "Name": "pending"
               },
               "PrivateDnsName": "",
               "PublicDnsName": "",
               "StateReason": {
                   "Code": "pending",
                   "Message": "pending"
               },
               "InstanceType": "t3.micro",
               "KeyName": "ecs-tutorial-key",
               "LaunchTime": "2025-01-13T10:30:00.000Z"
           }
       ]
   }
   ```

   Das Benutzerdatenskript konfiguriert den Amazon-ECS-Agent so, dass er die Instance bei Ihrem `MyCluster` registriert. Die Instance verwendet die IAM-Rolle `ecsInstanceRole`, die die erforderlichen Berechtigungen für den Agent bereitstellt.

## Container-Instances auflisten
<a name="AWSCLI_EC2_list_container_instances"></a>

Innerhalb weniger Minuten nach dem Start Ihrer Container-Instance registriert der Amazon ECS-Agent die Instance in Ihrem MyCluster Cluster. Die Container-Instances in einem Cluster können mit dem folgenden Befehl aufgelistet werden:

```
aws ecs list-container-instances --cluster MyCluster
```

Ausgabe:

```
{
    "containerInstanceArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:container-instance/container_instance_ID"
    ]
}
```

## Die Container-Instance beschreiben
<a name="AWSCLI_EC2_describe_container_instance"></a>

Wenn Sie den ARN oder die ID einer Container-Instance haben, können Sie mit dem Befehl **describe-container-instances** wichtige Informationen zu der Instance abrufen, wie z. B. die verbleibenden und registrierten CPU- und Speicherressourcen.

```
aws ecs describe-container-instances --cluster MyCluster --container-instances container_instance_ID
```

Ausgabe:

```
{
    "failures": [],
    "containerInstances": [
        {
            "status": "ACTIVE",
            "registeredResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "ec2InstanceId": "instance_id",
            "agentConnected": true,
            "containerInstanceArn": "arn:aws:ecs:us-west-2:aws_account_id:container-instance/container_instance_ID",
            "pendingTasksCount": 0,
            "remainingResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "runningTasksCount": 0,
            "attributes": [
                {
                    "name": "com.amazonaws.ecs.capability.privileged-container"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.17"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.json-file"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.syslog"
                }
            ],
            "versionInfo": {
                "agentVersion": "1.5.0",
                "agentHash": "b197edd",
                "dockerVersion": "DockerVersion: 1.7.1"
            }
        }
    ]
}
```

Hier finden Sie auch die Amazon-EC2-Instance-ID, mit der Sie die Instance in der Amazon-EC2-Konsole oder mit dem **aws ec2 describe-instances --instance-id *instance\$1id***-Befehl überwachen können.

## Eine Aufgabendefinition registrieren
<a name="AWSCLI_EC2_register_task_definition"></a>

Bevor Sie auf dem Amazon-ECS-Cluster eine Windows-Aufgabe ausführen können, müssen Sie eine Aufgabendefinition anmelden. Aufgabendefinitionen sind Listen zusammengefasster Container. Im folgenden Beispiel sehen Sie eine einfache Aufgabendefinition, die ein `nginx`-Image verwendet. Weitere Informationen zu den verfügbaren Parametern für die Aufgabendefinition finden Sie im Abschnitt [Amazon-ECS-Aufgabendefinitionen](task_definitions.md).

```
{
    "family": "nginx-task",
    "containerDefinitions": [
        {
            "name": "nginx",
            "image": "public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest",
            "cpu": 256,
            "memory": 512,
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "requiresCompatibilities": ["EC2"],
    "networkMode": "bridge"
}
```

Das obige JSON-Beispiel kann auf zwei Arten AWS CLI an die übergeben werden: Sie können die JSON-Aufgabendefinition als Datei speichern und sie zusammen mit der `--cli-input-json file://path_to_file.json` Option übergeben. Alternativ können Sie die Anführungszeichen in den JSON-Daten mit Escape-Zeichen versehen und die JSON-Container-Definitionen wie im Beispiel unten dargestellt in der Befehlszeile übergeben. Wenn Sie die Containerdefinitionen in der Befehlszeile übergeben möchten, müssen Sie in dem Befehl zusätzlich einen Parameter `--family` angeben, damit mehrere Versionen Ihrer Aufgabendefinition miteinander verbunden bleiben.

Verwendung einer JSON-Datei für Containerdefinitionen:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/nginx.json
```

Der Befehl **register-task-definition** gibt nach Abschluss der Registrierung eine Beschreibung der Aufgabendefinition zurück.

```
{
    "taskDefinition": {
        "taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/nginx-task:1",
        "family": "nginx-task",
        "revision": 1,
        "status": "ACTIVE",
        "containerDefinitions": [
            {
                "name": "nginx",
                "image": "public.ecr.aws/docker/library/nginx:latest",
                "cpu": 256,
                "memory": 512,
                "essential": true,
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "environment": [],
                "mountPoints": [],
                "volumesFrom": []
            }
        ],
        "volumes": [],
        "networkMode": "bridge",
        "compatibilities": [
            "EC2"
        ],
        "requiresCompatibilities": [
            "EC2"
        ]
    }
}
```

## Aufgabendefinitionen auflisten
<a name="AWSCLI_EC2_list_task_definitions"></a>

Sie können die Aufgabendefinitionen für Ihr Konto jederzeit mit dem Befehl **list-task-definitions** auflisten. In der Ausgabe dieses Befehls werden die Werte `family` und `revision` angezeigt, die Sie beim Aufruf von **create-service** gemeinsam verwenden können.

```
aws ecs list-task-definitions
```

Ausgabe:

```
{
    "taskDefinitionArns": [
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:2",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:3",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:4",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:5",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:6"
    ]
}
```

## Einen Service erstellen
<a name="AWSCLI_EC2_run_task"></a>

Nachdem Sie eine Aufgabe für Ihr Konto registriert und eine Container-Instance gestartet haben, die in Ihrem Cluster registriert ist, können Sie mithilfe der von Ihnen registrierten Aufgabendefinition einen Amazon-ECS-Service erstellen, der eine gewünschte Anzahl von Aufgaben gleichzeitig ausführt und verwaltet. In diesem Beispiel platzieren Sie eine einzelne Instanz der `nginx:1` Aufgabendefinition in Ihrem MyCluster Cluster.

```
aws ecs create-service --cluster MyCluster --service-name nginx-service --task-definition nginx-task:1 --desired-count 1
```

Ausgabe:

```
{
    "service": {
        "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
        "serviceName": "nginx-service",
        "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
        "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "desiredCount": 1,
        "runningCount": 0,
        "pendingCount": 0,
        "launchType": "EC2",
        "status": "ACTIVE",
        "createdAt": "2025-01-13T10:45:00.000Z"
    }
}
```

## Services aufzählen
<a name="AWSCLI_EC2_list_tasks"></a>

Listet die Services für Ihren Cluster auf. Der im vorherigen Abschnitt erstellte Service müsste angezeigt werden. Sie können die Service-ID oder den vollständigen ARN, die/der von diesem Befehl zurückgegeben wird, notieren und später zur Beschreibung des Service verwenden.

```
aws ecs list-services --cluster MyCluster
```

Ausgabe:

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:task/task_ID"
    ]
}
```

## Den Service beschreiben
<a name="AWSCLI_EC2_describe_service"></a>

Beschreiben Sie den Service mithilfe des folgenden Befehls, um weitere Informationen über den Service zu erhalten.

```
aws ecs describe-services --cluster MyCluster --services nginx-service
```

Ausgabe:

```
{
    "services": [
        {
            "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
            "serviceName": "nginx-service",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "desiredCount": 1,
            "runningCount": 1,
            "pendingCount": 0,
            "launchType": "EC2",
            "status": "ACTIVE",
            "createdAt": "2025-01-13T10:45:00.000Z",
            "events": [
                {
                    "id": "abcd1234-5678-90ab-cdef-1234567890ab",
                    "createdAt": "2025-01-13T10:45:30.000Z",
                    "message": "(service nginx-service) has started 1 tasks: (task abcd1234-5678-90ab-cdef-1234567890ab)."
                }
            ]
        }
    ]
}
```

## Die ausgeführte Aufgabe beschreiben
<a name="AWSCLI_EC2_describe_task"></a>

Nachdem Sie den Service beschrieben haben, führen Sie den folgenden Befehl aus, um weitere Informationen zu der Aufgabe zu erhalten, die als Teil Ihres Services ausgeführt wird.

```
aws ecs list-tasks --cluster MyCluster --service-name nginx-service
```

 Ausgabe: 

```
{
    "tasks": [
        {
            "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinitionArn": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "containerInstanceArn": "arn:aws:ecs:us-east-1:aws_account_id:container-instance/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "lastStatus": "RUNNING",
            "desiredStatus": "RUNNING",
            "containers": [
                {
                    "containerArn": "arn:aws:ecs:us-east-1:aws_account_id:container/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab/abcd1234-5678-90ab-cdef-1234567890ab",
                    "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
                    "name": "nginx",
                    "lastStatus": "RUNNING",
                    "networkBindings": [
                        {
                            "bindIP": "0.0.0.0",
                            "containerPort": 80,
                            "hostPort": 80,
                            "protocol": "tcp"
                        }
                    ]
                }
            ],
            "createdAt": "2025-01-13T10:45:00.000Z",
            "startedAt": "2025-01-13T10:45:30.000Z"
        }
    ]
}
```

## Den Webserver testen
<a name="AWSCLI_EC2_test_web_server"></a>

**So testen Sie den Webserver**

1. Rufen Sie die öffentliche IP-Adresse Ihrer Container-Instance ab, indem Sie den folgenden Befehl ausführen.

   ```
   aws ec2 describe-instances --instance-ids i-abcd1234 --query 'Reservations[0].Instances[0].PublicIpAddress' --output text
   ```

   Ausgabe:

   ```
   203.0.113.25
   ```

1. Führen Sie nach dem Abrufen der IP-Adresse den folgenden `curl`-Befehl mit der IP-Adresse aus.

   ```
   curl http://203.0.113.25
   ```

   Ausgabe:

   ```
   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   ...
   </head>
   <body>
   <h1>Welcome to nginx!</h1>
   <p>If you can see this page, the nginx web server is successfully installed and working.</p>
   ...
   </body>
   </html>
   ```

   Die nginx-Willkommensseite bestätigt, dass Ihr Service erfolgreich ausgeführt wird und über das Internet zugänglich ist.

## Bereinigen von Ressourcen
<a name="AWSCLI_EC2_clean_up_resources"></a>

Bereinigen Sie die Ressourcen, die Sie in diesem Tutorial erstellt haben, damit keine Gebühren anfallen.

**So bereinigen Sie Ressourcen**

1. Aktualisieren Sie den Service so, dass er keine gewünschten Aufgaben hat, und löschen Sie dann den Service.

   ```
   aws ecs update-service --cluster MyCluster --service nginx-service --desired-count 0
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "desiredCount": 0,
           "runningCount": 1,
           "pendingCount": 0,
           "status": "ACTIVE"
       }
   }
   ```

1. Warten Sie, bis die laufenden Aufgaben beendet sind, und löschen Sie dann den Service.

   ```
   aws ecs delete-service --cluster MyCluster --service nginx-service
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "status": "DRAINING"
       }
   }
   ```

1. Beenden Sie die Container-Instance, die Sie erstellt haben.

   ```
   aws ec2 terminate-instances --instance-ids i-abcd1234
   {
       "TerminatingInstances": [
           {
               "InstanceId": "i-abcd1234",
               "CurrentState": {
                   "Code": 32,
                   "Name": "shutting-down"
               },
               "PreviousState": {
                   "Code": 16,
                   "Name": "running"
               }
           }
       ]
   }
   ```

1. Bereinigen Sie die Sicherheitsgruppe und das Schlüsselpaar, die Sie erstellt haben.

   ```
   aws ec2 delete-security-group --group-id sg-abcd1234
   aws ec2 delete-key-pair --key-name ecs-tutorial-key
   rm ecs-tutorial-key.pem
   ```

1. Löschen Sie den Amazon-ECS-Cluster.

   ```
   aws ecs delete-cluster --cluster MyCluster
   {
       "cluster": {
           "clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
           "clusterName": "MyCluster",
           "status": "INACTIVE"
       }
   }
   ```

# Konfiguration von Amazon ECS für die Überwachung von CloudWatch Ereignissen
<a name="ecs_cwet"></a>

Erfahren Sie, wie Sie eine einfache Lambda-Funktion einrichten, die auf Aufgabenereignisse wartet und diese in einen CloudWatch Log-Log-Stream schreibt.

## Voraussetzung: Einrichten eines Testclusters
<a name="cwet_step_1"></a>

Wenn Sie über kein aktives Cluster verfügen, mit dem Sie Ereignisse erfassen, führen Sie die Schritte unter [Erstellen eines Amazon-ECS-Clusters für Fargate-Workloads](create-cluster-console-v2.md) aus, um eines zu erstellen. Am Ende dieses Tutorials führen Sie eine Aufgabe auf diesem Cluster aus, um zu testen, ob Sie Ihre Lambda-Funktion korrekt konfiguriert haben. 

## Schritt 1: Erstellen der Lambda-Funktion
<a name="cwet_step_2"></a>

In diesem Verfahren erstellen Sie eine einfache Lambda-Funktion, die als Ziel für Amazon-ECS-Ereignis-Stream-Nachrichten dient. 

1. Öffnen Sie die AWS Lambda Konsole unter. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)

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

1. Verfahren Sie auf dem Bildschirm **Author from scratch** wie folgt:

   1. Geben Sie für **Name** einen Wert ein. 

   1. Wählen Sie für **Runtime** (Laufzeit) Ihre Python-Version aus, etwa **Python 3.9**.

   1. Wählen Sie unter **Role (Rolle)** die Option **Create a new role with basic Lambda permissions (Eine neue Rolle mit den grundlegenden Lambda-Berechtigungen erstellen)** aus.

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

1. Bearbeiten Sie im Bereich **Function code** den Beispiel-Code entsprechend dem folgenden Beispiel:

   ```
   import json
   
   def lambda_handler(event, context):
       if event["source"] != "aws.ecs":
          raise ValueError("Function only supports input from events with a source type of: aws.ecs")
          
       print('Here is the event:')
       print(json.dumps(event))
   ```

   Dies ist eine einfache Python 3.9-Funktion, mit der das von Amazon ECS gesendete Ereignis gedruckt wird. Wenn alles korrekt konfiguriert ist, sehen Sie am Ende dieses Tutorials, dass die Ereignisdetails im CloudWatch Log-Protokollstream angezeigt werden, der dieser Lambda-Funktion zugeordnet ist.

1. Wählen Sie **Speichern**.

## Schritt 2: Registrieren von Ereignisregeln
<a name="cwet_step_3"></a>

 Als Nächstes erstellen Sie eine CloudWatch Ereignisregel, die Aufgabenereignisse erfasst, die aus Ihren Amazon ECS-Clustern stammen. Diese Regel erfasst alle Ereignisse, die aus allen Clustern innerhalb des Kontos stammen, in dem sie definiert wurde. Die Aufgabennachrichten selbst enthalten Informationen über die Ereignisquelle, einschließlich dem Cluster, in dem sie sich befindet. Sie können diese verwenden, um Ereignisse programmgesteuert zu filtern und zu sortieren. 

**Anmerkung**  
Wenn Sie die verwenden, AWS-Managementkonsole um eine Ereignisregel zu erstellen, fügt die Konsole automatisch die IAM-Berechtigungen hinzu, die erforderlich sind, um CloudWatch Events die Berechtigung zum Aufrufen Ihrer Lambda-Funktion zu erteilen. Wenn Sie mithilfe von eine Ereignisregel erstellen AWS CLI, müssen Sie diese Berechtigung explizit erteilen. Weitere Informationen finden Sie unter [Ereignisse bei Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) und [ EventBridge Amazon-Ereignismuster](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html) im * EventBridge Amazon-Benutzerhandbuch*.

**Umleiten von Ereignissen an Ihre Lambda-Funktion**

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 **Events (Ereignisse)**, **Rules (Regeln)**, **Create rule (Regel erstellen)** aus.

1. Wählen Sie für **Event Source** als Ereignisquelle **ECS** aus. Standardmäßig gilt die Regel für alle Amazon-ECS-Ereignisse all Ihrer Amazon-ECS-Gruppen. Alternativ können Sie bestimmte Ereignisse oder eine bestimmte Amazon-ECS-Gruppe auswählen.

1. Wählen Sie für **Targets** (Ziele) die Option **Add target** (Ziel hinzufügen) und für **Target type** (Zieltyp) die Option **Lambda function** (Lambda-Funktion) und danach Ihre Lambda-Funktion aus.

1. Wählen Sie **Details konfigurieren**.

1. Geben Sie für **Rule definition** einen Namen und eine Beschreibung für Ihre Regel ein und wählen Sie **Create rule** aus.

## Schritt 3: Erstellen einer Aufgabendefinition
<a name="cwet_step_task-def"></a>

Erstellen Sie eine Aufgabendefinition.

1. Öffnen Sie die Konsole auf [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Wählen Sie im Navigationsbereich **Task Definitions** aus.

1. Wählen Sie **Create new Task Definition** (Neue Aufgabendefinition erstellen), **Create new revision with JSON** (Neue Revision mit JSON) erstellen.

1. Kopieren Sie die folgende Beispielaufgabendefinition, fügen Sie sie in das Feld ein, und wählen Sie dann **Save (Speichern)**.

   ```
   {
      "containerDefinitions": [ 
         { 
            "command": [
               "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
            ],
            "entryPoint": [
               "sh",
               "-c"
            ],
            "essential": true,
            "image": "public.ecr.aws/docker/library/httpd:2.4",
            "logConfiguration": { 
               "logDriver": "awslogs",
               "options": { 
                  "awslogs-group" : "/ecs/fargate-task-definition",
                  "awslogs-region": "us-east-1",
                  "awslogs-stream-prefix": "ecs"
               }
            },
            "name": "sample-fargate-app",
            "portMappings": [ 
               { 
                  "containerPort": 80,
                  "hostPort": 80,
                  "protocol": "tcp"
               }
            ]
         }
      ],
      "cpu": "256",
      "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family": "fargate-task-definition",
      "memory": "512",
      "networkMode": "awsvpc",
      "runtimePlatform": {
           "operatingSystemFamily": "LINUX"
       },
      "requiresCompatibilities": [ 
          "FARGATE" 
       ]
   }
   ```

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

## Schritt 4: Testen Ihrer Regel
<a name="cwet_step_4"></a>

 Schließlich erstellen Sie eine CloudWatch Ereignisregel, die Aufgabenereignisse erfasst, die aus Ihren Amazon ECS-Clustern stammen. Diese Regel erfasst alle Ereignisse, die aus allen Clustern innerhalb des Kontos stammen, in dem sie definiert wurde. Die Aufgabennachrichten selbst enthalten Informationen über die Ereignisquelle, einschließlich dem Cluster, in dem sie sich befindet. Sie können diese verwenden, um Ereignisse programmgesteuert zu filtern und zu sortieren. 

**Testen Ihrer Regel**

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 **Task definitions** (Aufgabendefinitionen).

1. Wählen Sie **console-sample-app-static**und anschließend **Bereitstellen**, **Neue Aufgabe ausführen aus**.

1. Wählen Sie für **Cluster** die Option Standard und wählen Sie dann **Deploy** (Bereitstellen) aus.

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** und wählen Sie die Protokollgruppe für Ihre Lambda-Funktion aus (z. B. ***my-function*/aws/lambda/**).

1. Wählen Sie einen Protokollstream aus, um die Ereignisdaten anzuzeigen. 

# Senden von Warnungen von Amazon Simple Notification Service bei angehaltenen Amazon-ECS-Aufgaben
<a name="ecs_cwet2"></a>

Konfigurieren Sie eine EventBridge Amazon-Ereignisregel, die nur Aufgabenereignisse erfasst, bei denen die Ausführung der Aufgabe beendet wurde, weil einer ihrer wichtigsten Container beendet wurde. Das Ereignis sendet nur Aufgabenereignisse mit einer bestimmten `stoppedReason`-Eigenschaft an das zugewiesene Amazon SNS-Thema.

## Voraussetzung: Einrichten eines Testclusters
<a name="cwet2_step_1"></a>

 Wenn Sie keinen laufenden Cluster haben, von dem Sie Ereignisse erfassen können, folgen Sie den Schritten unter [Erste Schritte mit der Konsole unter Verwendung von Linux-Containern auf AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/getting-started-fargate.html#get-started-fargate-cluster), um einen zu erstellen. Am Ende dieses Tutorials führen Sie eine Aufgabe auf diesem Cluster aus, um zu testen, ob Sie Ihr Amazon SNS-Thema und Ihre Amazon EventBridge SNS-Regel korrekt konfiguriert haben. 

## Voraussetzung: Berechtigungen für Amazon SNS konfigurieren
<a name="cwet2_step_1a"></a>

Verwenden Sie EventBridge die Befehle aws sns get-topic-attributes und aws sns, um die Veröffentlichung in einem Amazon SNS-Thema zu ermöglichen. set-topic-attributes 

Informationen zum Hinzufügen der Berechtigung finden Sie unter [Amazon-SNS-Berechtigungen](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html#eb-sns-permissions) im *Entwicklerhandbuch für Amazon Simple Notification Service*

Fügen Sie die folgenden Berechtigungen hinzu:

```
{
  "Sid": "PublishEventsToMyTopic",
  "Effect": "Allow",
  "Principal": {
     "Service": "events.amazonaws.com"
  },
  "Action": "sns: Publish",
  "Resource": "arn:aws:sns:region:account-id:TaskStoppedAlert",
}
```

## Schritt 1: Erstellen und Abonnieren eines Amazon-SNS-Themas
<a name="cwet2_step_2"></a>

 Mit diesem Tutorial konfigurieren Sie ein Amazon SNS-Thema, das als Ereignisziel für Ihre neue Ereignisregel dient. 

Informationen zum Erstellen und Abonnieren eines Amazon-SNS-Themas finden Sie unter [Erste Schritte mit Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-getting-started.html#step-create-queue) im *Entwicklerhandbuch zu Amazon Simple Notification Service* und verwenden Sie die folgende Tabelle, um zu bestimmen, welche Optionen auszuwählen sind.


| Option | Value | 
| --- | --- | 
|  Typ  | Standard | 
| Name |  TaskStoppedAlert  | 
| Protocol (Protokoll) | Email | 
| Endpoint |  Eine E-Mail-Adresse, auf die Sie aktuell Zugriff haben  | 

## Schritt 2: Registrieren von Ereignisregeln
<a name="cwet2_step_3"></a>

 Als nächstes registrieren Sie eine Ereignisregel, die nur „Aufgabe angehalten“-Ereignisse für Aufgaben mit angehaltenen Containern erfasst. 

Informationen zum Erstellen und Abonnieren eines Amazon SNS SNS-Themas finden Sie unter [Erstellen einer Regel in Amazon EventBridge im * EventBridge Amazon-Benutzerhandbuch*](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html). Verwenden Sie die folgende Tabelle, um zu bestimmen, welche Optionen Sie auswählen müssen.


| Option | Wert | 
| --- | --- | 
|  Art der Regel  |  Regel mit einem Ereignismuster  | 
| Ereignisquelle | AWS Veranstaltungen oder EventBridge Partnerveranstaltungen | 
| Ereignismuster |  Benutzerdefiniertes Muster (JSON-Editor)  | 
| Ereignismuster |  <pre>{<br />   "source":[<br />      "aws.ecs"<br />   ],<br />   "detail-type":[<br />      "ECS Task State Change"<br />   ],<br />   "detail":{<br />      "lastStatus":[<br />         "STOPPED"<br />      ],<br />      "stoppedReason":[<br />         "Essential container in task exited"<br />      ]<br />   }<br />}</pre> | 
| Zieltyp |  AWS Service  | 
| Target | SNS-Thema | 
| Thema |  TaskStoppedAlert (Das Thema, das Sie in Schritt 1 erstellt haben)  | 

## Schritt 3: Testen Ihrer Regel
<a name="cwet2_step_4"></a>

Stellen Sie sicher, dass die Regel funktioniert, indem Sie eine Aufgabe ausführen, die kurz nach dem Start beendet wird. Wenn Ihre Ereignisregel korrekt konfiguriert ist, erhalten Sie innerhalb weniger Minuten eine E-Mail-Nachricht mit dem Ereignistext. Wenn Sie über eine vorhandene Aufgabendefinition verfügen, die die Regelanforderungen erfüllen kann, führen Sie eine Aufgabe mit dieser aus. Wenn dies nicht der Fall ist, führen Sie die folgenden Schritte durch die Registrierung einer Fargate-Aufgabendefinition und deren Ausführung.

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** (Aufgabendefinitionen) aus.

1. Wählen Sie **Create new task definition** (Neue Aufgabendefinition erstellen), **Create new task definition with JSON** (Neue Aufgabendefinition mit JSON) erstellen.

1. Bearbeiten Sie im JSON-Editorfeld Ihre JSON-Datei und kopieren Sie Folgendes in den Editor.

   ```
   {
      "containerDefinitions":[
         {
            "command":[
               "sh",
               "-c",
               "sleep 5"
            ],
            "essential":true,
            "image":"public.ecr.aws/amazonlinux/amazonlinux:latest",
            "name":"test-sleep"
         }
      ],
      "cpu":"256",
      "executionRoleArn":"arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family":"fargate-task-definition",
      "memory":"512",
      "networkMode":"awsvpc",
      "requiresCompatibilities":[
         "FARGATE"
      ]
   }
   ```

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

**So führen Sie eine Aufgabe über die Konsole aus**

1. Öffnen Sie die Konsole auf [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Wählen Sie auf der Seite **Cluster** den Cluster aus, den Sie in den Voraussetzungen erstellt haben.

1. Von der Registerkarte **Tasks (Aufgaben)** wählen Sie **Ausführen einer neuen Aufgabe**.

1. Für **Anwendungstyp**, wählen Sie **Aufgabe** aus.

1. Wählen Sie für **Aufgabendefinition** die Option **fargate-task-definition**.

1. Geben Sie für **Desired tasks** (Gewünschte Aufgaben) die Anzahl der Aufgaben an, die gestartet werden sollen.

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

# Verketten mehrzeiliger oder Stack-Trace-Protokollnachrichten in Amazon ECS
<a name="firelens-concatanate-multiline"></a>

Ab Version 2.22.0 von Fluent Bit ist ein mehrzeiliger Filter enthalten. AWS Der Mehrzeilenfilter hilft bei der Verkettung von Protokollmeldungen, die ursprünglich zu einem Kontext gehören, aber auf mehrere Datensätze oder Protokollzeilen aufgeteilt wurden. Weitere Informationen zum mehrzeiligen Filter finden Sie in der [ Fluent-Bit-Dokumentation](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace). 

Häufige Beispiele für geteilte Protokollmeldungen sind:
+ Stack-Traces. 
+ Anwendungen, die Protokolle auf mehreren Zeilen drucken. 
+ Protokollmeldungen, die geteilt wurden, weil sie länger waren als die angegebene maximale Puffergröße der Laufzeit. [Sie können Protokollnachrichten, die nach der Container-Laufzeit aufgeteilt sind, verketten, indem Sie dem Beispiel unter folgen: Beispiel: Container-Logs verketten. GitHub FireLens Partial/Split ](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/filter-multiline-partial-message-mode)

## Erforderliche IAM-Berechtigungen
<a name="iam-permissions"></a>

Sie verfügen über die erforderlichen IAM-Berechtigungen, damit der Container-Agent die Container-Images aus Amazon ECR abrufen kann und der Container Protokolle an CloudWatch Logs weiterleitet.

Für diese Berechtigungen müssen Sie über die folgenden Rollen verfügen: 
+ Eine Aufgaben-IAM-Rolle. 
+ Eine IAM-Rolle für die Aufgabenausführung 

Sie benötigen die folgenden Berechtigungen:
+ `logs:CreateLogStream`
+ `logs:CreateLogGroup`
+ `logs:PutLogEvents`

## Festlegen, wann die Einstellung für mehrzeiliges Protokoll verwendet werden soll
<a name="determine-filter"></a>

Im Folgenden finden Sie Beispiele für Protokollausschnitte, die Sie in der CloudWatch Logs-Konsole mit der Standardprotokolleinstellung sehen. Sie können sich die Zeile ansehen, die mit `log` beginnt, um festzustellen, ob Sie den Mehrzeilenfilter benötigen. Wenn der Kontext derselbe ist, können Sie die Einstellung für das mehrzeilige Protokoll verwenden. In diesem Beispiel ist der Kontext „com.myproject.model“. MyProject“.

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "source=": "stdout", "log": ": "     at com.myproject.modele.(MyProject.badMethod.java:22)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.badMethod(MyProject.java:22)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout", "log": ": "     at com.myproject.modele.(MyProject.oneMoreMethod.java:18)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE,
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

Nachdem Sie die mehrzeilige Protokolleinstellung verwendet haben, sieht die Ausgabe ähnlich aus wie im Beispiel unten. 

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout",...
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log:    "September 20, 2022 06:41:48 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    
    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at   
    at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18) com.myproject.module.MyProject.main(MyProject.java:6)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:2"
     }
```

## Analyse und Verkettung von Optionen
<a name="parse-multiline-log"></a>

Um Protokolle zu analysieren und Zeilen zu verketten, die aufgrund von Zeilenumbrüchen geteilt wurden, können Sie eine dieser beiden Optionen verwenden.
+ Verwenden Sie Ihre eigene Parserdatei, die die Regeln zum Analysieren und Verketten von Zeilen enthält, die zu derselben Nachricht gehören.
+ Einen integrierten Parser für Fluent Bit verwenden. Eine Liste der Sprachen, die von den integrierten Parsern Fluent Bit unterstützt werden, finden Sie unter [Fluent-Bit-Dokumentation.](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace)

Das folgende Tutorial führt Sie durch die Schritte für jeden Anwendungsfall. Die Schritte zeigen Ihnen, wie Sie mehrere Zeilen verketten und die Protokolle an Amazon senden. CloudWatch Sie können ein anderes Ziel für Ihre Protokolle angeben.

### Beispiel: Verwenden eines Parsers, den Sie erstellen
<a name="customer-parser"></a>

In diesem Beispiel führen Sie die folgenden Schritte aus: 

1. Erstellen und laden Sie das Image für einen Fluent-Bit-Container hoch. 

1. Erstellen und laden Sie das Image für eine mehrzeilige Demo-Anwendung hoch, die einen mehrzeiligen Stack-Trace ausführt, fehlschlägt und generiert.

1. Erstellen Sie die Aufgabendefinition und führen Sie die Aufgabe aus. 

1. Zeigen Sie die Protokolle an, um zu überprüfen, ob Nachrichten, die sich über mehrere Zeilen erstrecken, verkettet erscheinen. 

**Erstellen und Hochladen des Images für einen Fluent-Bit-Container**

Dieses Image enthält die Parserdatei, in der Sie den regulären Ausdruck angeben, und eine Konfigurationsdatei, die auf die Parser-Datei verweist. 

1. Erstellen Sie einen Ordner mit dem Namen `FluentBitDockerImage`. 

1. Erstellen Sie innerhalb des Ordners eine Parserdatei, die die Regeln zum Analysieren des Protokolls und zum Verketten von Zeilen enthält, die zu derselben Nachricht gehören.

   1. Fügen Sie den folgenden Inhalt in die Parser-Datei ein:

      ```
      [MULTILINE_PARSER]
          name          multiline-regex-test
          type          regex
          flush_timeout 1000
          #
          # Regex rules for multiline parsing
          # ---------------------------------
          #
          # configuration hints:
          #
          #  - first state always has the name: start_state
          #  - every field in the rule must be inside double quotes
          #
          # rules |   state name  | regex pattern                  | next state
          # ------|---------------|--------------------------------------------
          rule      "start_state"   "/(Dec \d+ \d+\:\d+\:\d+)(.*)/"  "cont"
          rule      "cont"          "/^\s+at.*/"                     "cont"
      ```

      Wenn Sie Ihr Regex-Muster anpassen, empfehlen wir Ihnen, den Ausdruck mit einem Editor für reguläre Ausdrücke zu testen.

   1. Speichern Sie die Datei als `parsers_multiline.conf`. 

1. Erstellen Sie im `FluentBitDockerImage`-Ordner eine benutzerdefinierte Konfigurationsdatei, die auf die Parserdatei verweist, die Sie im vorherigen Schritt erstellt haben.

   Weitere Informationen zur benutzerdefinierten Konfigurationsdatei finden Sie unter [Angeben einer benutzerdefinierten Konfigurationsdatei](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) im *Entwicklerhandbuch für Amazon Elastic Container Service* 

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      [SERVICE]
          flush                 1
          log_level             info
          parsers_file          /parsers_multiline.conf
          
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      multiline-regex-test
      ```
**Anmerkung**  
Sie müssen den absoluten Pfad des Parsers verwenden. 

   1. Speichern Sie die Datei als `extra.conf`. 

1. Erstellen Sie im `FluentBitDockerImage`-Ordner die Dockerfile mit dem Fluent-Bit-Image und den von Ihnen erstellten Parser- und Konfigurationsdateien.

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      
      ADD parsers_multiline.conf /parsers_multiline.conf
      ADD extra.conf /extra.conf
      ```

   1. Speichern Sie die Datei als `Dockerfile`.

1. Erstellen Sie mit der Dockerfile ein benutzerdefiniertes Fluent-Bit-Image mit dem Parser und benutzerdefinierten Konfigurationsdateien.
**Anmerkung**  
Sie können die Parser-Datei und die Konfigurationsdatei an einer beliebigen Stelle im Docker-Image platzieren, es sei `/fluent-bit/etc/fluent-bit.conf` denn, dieser Dateipfad wird von verwendet. FireLens

   1. Entwickeln Sie das Image: `docker build -t fluent-bit-multiline-image.`

      Wobei: `fluent-bit-multiline-image` der Name für das Image in diesem Beispiel ist.

   1. Überprüfen Sie, ob das Image korrekt erstellt wurde: `docker images —filter reference=fluent-bit-multiline-image` 

      Bei Erfolg zeigt die Ausgabe das Image und das `latest`-Tag.

1. Laden Sie das benutzerdefinierte Fluent-Bit-Image in Amazon Elastic Container Registry hoch.

   1. Erstellen Sie ein Amazon-ECR-Repository zum Speichern des Images: `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Wobei: `fluent-bit-multiline-repo` der Name für das Repository und `us-east-1` die Region in diesem Beispiel ist. 

      Die Ausgabe gibt Ihnen die Details des neuen Repositorys. 

   1. Markieren Sie Ihr Image mit dem `repositoryUri`-Wert aus der vorherigen Ausgabe: `docker tag fluent-bit-multiline-image repositoryUri` 

      Beispiel: `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Führen Sie das Docker-Image aus, um zu überprüfen, ob es korrekt ausgeführt wurde: `docker images —filter reference=repositoryUri`

      In der Ausgabe ändert sich der Repository-Name von fluent-bit-multiline-repo zu. `repositoryUri`

   1. Authentifizieren Sie sich bei Amazon ECR, indem Sie den Befehl `aws ecr get-login-password` ausführen und die Registry-ID angeben, bei der Sie sich authentifizieren möchten: `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Beispiel: `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Eine erfolgreiche Anmeldemeldung wird angezeigt.

   1. Verschieben Sie das Image zu Amazon ECR: `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Beispiel: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Erstellen und Hochladen des Images für eine mehrzeilige Demo-Anwendung**

Dieses Image enthält eine Python-Skriptdatei, die die Anwendung ausführt, und eine Beispielprotokolldatei. 

Wenn Sie die Aufgabe ausführen, simuliert die Anwendung Ausführungen, schlägt dann fehl und erstellt einen Stack-Trace. 

1. Erstellen Sie einen Ordner mit dem Namen `multiline-app`: `mkdir multiline-app` 

1. Erstellen Sie eine Python-Skriptdatei.

   1. Erstellen Sie im `multiline-app`-Ordner eine Datei und nennen Sie sie `main.py`.

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Speichern Sie die `main.py`-Datei.

1. Erstellen Sie eine Beispielprotokolldatei. 

   1. Erstellen Sie im `multiline-app`-Ordner eine Datei und nennen Sie sie `test.log`.

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      single line...
      Dec 14 06:41:08 Exception in thread "main" java.lang.RuntimeException: Something has gone wrong, aborting!
          at com.myproject.module.MyProject.badMethod(MyProject.java:22)
          at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)
          at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)
          at com.myproject.module.MyProject.someMethod(MyProject.java:10)
          at com.myproject.module.MyProject.main(MyProject.java:6)
      another line...
      ```

   1. Speichern Sie die `test.log`-Datei.

1. Erstellen Sie innerhalb des Ordners `multiline-app` die Docker-Datei.

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Speichern Sie die `Dockerfile`-Datei.

1. Erstellen Sie mit der Dockerfile ein Image.

   1. Entwickeln Sie das Image: `docker build -t multiline-app-image `

      Wobei: `multiline-app-image` der Name für das Image in diesem Beispiel ist.

   1. Überprüfen Sie, ob das Image korrekt erstellt wurde: `docker images —filter reference=multiline-app-image` 

      Bei Erfolg zeigt die Ausgabe das Image und das `latest`-Tag.

1. Laden Sie das Image in Amazon-Elastic-Container-Registry hoch.

   1. Erstellen Sie ein Amazon-ECR-Repository zum Speichern des Images: `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Wobei: `multiline-app-repo` der Name für das Repository und `us-east-1` die Region in diesem Beispiel ist. 

      Die Ausgabe gibt Ihnen die Details des neuen Repositorys. Notieren Sie sich den `repositoryUri`-Wert, da Sie ihn in den nächsten Schritten benötigen. 

   1. Markieren Sie Ihr Image mit dem `repositoryUri`-Wert aus der vorherigen Ausgabe: `docker tag multiline-app-image repositoryUri` 

      Beispiel: `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Führen Sie das Docker-Image aus, um zu überprüfen, ob es korrekt ausgeführt wurde: `docker images —filter reference=repositoryUri`

      In der Ausgabe ändert sich der Repository-Name von `multiline-app-repo` in den `repositoryUri`-Wert.

   1. Verschieben Sie das Image zu Amazon ECR: `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Beispiel: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Erstellen einer Aufgabendefinition und Ausführen der Aufgabe**

1. Erstellen Sie eine Aufgabendefinitionsdatei mit dem Dateinamen `multiline-task-definition.json`. 

1. Fügen Sie den folgenden Inhalt in die `multiline-task-definition.json`-Datei ein: 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Ersetzen Sie Folgendes in der `multiline-task-definition.json`-Aufgabendefinition:

   1. `task role ARN`

      Um den Aufgabenrollen-ARN zu finden, gehen Sie zur IAM-Konsole. Wählen Sie **Roles** (Rollen) und suchen Sie die `ecs-task-role-for-firelens`-Aufgabenrolle, die Sie erstellt haben. Wählen Sie die Rolle aus und kopieren Sie den **ARN**, der im Abschnitt **Summary** (Zusammenfassung) angezeigt wird.

   1. `execution role ARN`

      Verwenden Sie die IAM-Konsole, um die Ausführungsrollen-ARN zu finden. Wählen Sie **Roles** (Rollen) aus und finden Sie die `ecsTaskExecutionRole`-Rolle. Wählen Sie die Rolle aus und kopieren Sie den **ARN**, der im Abschnitt **Summary** (Zusammenfassung) angezeigt wird.

   1. `aws_account_id`

      Um Ihr `aws_account_id` zu finden, melden Sie sich bei AWS-Managementkonsole an. Wählen Sie oben rechts Ihren Benutzernamen und kopieren Sie Ihre Konto-ID.

   1. `us-east-1`

      Ersetzen Sie die Region bei Bedarf.

1. Registrieren Sie die Aufgabendefinitionsdatei: `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region region` 

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** (Aufgabendefinitionen) und dann die `firelens-example-multiline`-Familie aus, da wir die Aufgabendefinition für diese Familie in der ersten Zeile der Aufgabendefinition oben registriert haben.

1. Wählen Sie die neueste Version aus. 

1. Wählen Sie **Bereitstellen**, **Aufgabe ausführen** aus. 

1. Wählen Sie auf der Seite **Task ausführen** für **Cluster** den Cluster aus, und wählen Sie dann unter **Netzwerk** für **Subnetze** die verfügbaren Subnetze für Ihre Aufgabe aus. 

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

**Stellen Sie sicher, dass mehrzeilige Protokollnachrichten in Amazon verkettet CloudWatch angezeigt werden**

1. Öffnen Sie die Konsole unter. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Erweitern Sie im Navigationsbereich **Logs** (Protokolle) und wählen Sie **Log groups** (Protokollgruppen) aus. 

1. Wählen Sie die Protokollgruppe `multiline-test/applicatio` aus. 

1. Wählen Sie das Protokoll aus. Nachrichten anzeigen. Zeilen, die mit den Regeln in der Parser-Datei übereinstimmen, werden verkettet und werden als einzelne Nachricht angezeigt. 

   Das folgende Protokoll-Snippet zeigt Zeilen an, die in einem einzigen Java-Stack-Trace-Ereignis verkettet sind: 

   ```
   {
       "container_id": "xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)\n    at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)\n    at com.myproject.module.MyProject.someMethod(MyProject.java:10)\n    at com.myproject.module.MyProject.main(MyProject.java:6)",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   Das folgende Protokoll-Snippet zeigt, wie dieselbe Meldung mit nur einer einzigen Zeile angezeigt wird, wenn Sie einen Amazon-ECS-Container ausführen, der nicht für die Verkettung von mehrzeiligen Protokollmeldungen konfiguriert ist. 

   ```
   {
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   }
   ```

### Beispiel: Verwenden eines integrierten Parsers für Fluent Bit
<a name="fluent-bit-parser"></a>

In diesem Beispiel führen Sie die folgenden Schritte aus: 

1. Erstellen und laden Sie das Image für einen Fluent-Bit-Container hoch. 

1. Erstellen und laden Sie das Image für eine mehrzeilige Demo-Anwendung hoch, die einen mehrzeiligen Stack-Trace ausführt, fehlschlägt und generiert.

1. Erstellen Sie die Aufgabendefinition und führen Sie die Aufgabe aus. 

1. Zeigen Sie die Protokolle an, um zu überprüfen, ob Nachrichten, die sich über mehrere Zeilen erstrecken, verkettet erscheinen. 

**Erstellen und Hochladen des Images für einen Fluent-Bit-Container**

Dieses Image enthält eine Konfigurationsdatei, die auf den Fluent-Bit-Parser verweist. 

1. Erstellen Sie einen Ordner mit dem Namen `FluentBitDockerImage`. 

1. Erstellen Sie innerhalb des `FluentBitDockerImage`-Ordners eine benutzerdefinierte Konfigurationsdatei, die auf die integrierte Parser-Datei von Fluent Bit verweist.

   Weitere Informationen zur benutzerdefinierten Konfigurationsdatei finden Sie unter [Angeben einer benutzerdefinierten Konfigurationsdatei](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) im *Entwicklerhandbuch für Amazon Elastic Container Service* 

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      go
      ```

   1. Speichern Sie die Datei als `extra.conf`. 

1. Erstellen Sie im `FluentBitDockerImage`-Ordner die Dockerfile mit dem Fluent-Bit-Image und den von Ihnen erstellten Parser- und Konfigurationsdateien.

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      ADD extra.conf /extra.conf
      ```

   1. Speichern Sie die Datei als `Dockerfile`.

1. Erstellen Sie mit der Dockerfile ein benutzerdefiniertes Fluent-Bit-Image mit der enthaltenen benutzerdefinierten Konfigurationsdatei.
**Anmerkung**  
Sie können die Konfigurationsdatei an einer beliebigen Stelle im Docker-Image platzieren, es sei `/fluent-bit/etc/fluent-bit.conf` denn, dieser Dateipfad wird von FireLens verwendet.

   1. Entwickeln Sie das Image: `docker build -t fluent-bit-multiline-image.`

      Wobei: `fluent-bit-multiline-image` der Name für das Image in diesem Beispiel ist.

   1. Überprüfen Sie, ob das Image korrekt erstellt wurde: `docker images —filter reference=fluent-bit-multiline-image` 

      Bei Erfolg zeigt die Ausgabe das Image und das `latest`-Tag.

1. Laden Sie das benutzerdefinierte Fluent-Bit-Image in Amazon Elastic Container Registry hoch.

   1. Erstellen Sie ein Amazon-ECR-Repository zum Speichern des Images: `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Wobei: `fluent-bit-multiline-repo` der Name für das Repository und `us-east-1` die Region in diesem Beispiel ist. 

      Die Ausgabe gibt Ihnen die Details des neuen Repositorys. 

   1. Markieren Sie Ihr Image mit dem `repositoryUri`-Wert aus der vorherigen Ausgabe: `docker tag fluent-bit-multiline-image repositoryUri` 

      Beispiel: `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Führen Sie das Docker-Image aus, um zu überprüfen, ob es korrekt ausgeführt wurde: `docker images —filter reference=repositoryUri`

      In der Ausgabe ändert sich der Repository-Name von fluent-bit-multiline-repo zu. `repositoryUri`

   1. Authentifizieren Sie sich bei Amazon ECR, indem Sie den Befehl `aws ecr get-login-password` ausführen und die Registry-ID angeben, bei der Sie sich authentifizieren möchten: `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Beispiel: `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Eine erfolgreiche Anmeldemeldung wird angezeigt.

   1. Verschieben Sie das Image zu Amazon ECR: `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Beispiel: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Erstellen und Hochladen des Images für eine mehrzeilige Demo-Anwendung**

Dieses Image enthält eine Python-Skriptdatei, die die Anwendung ausführt, und eine Beispielprotokolldatei. 

1. Erstellen Sie einen Ordner mit dem Namen `multiline-app`: `mkdir multiline-app` 

1. Erstellen Sie eine Python-Skriptdatei.

   1. Erstellen Sie im `multiline-app`-Ordner eine Datei und nennen Sie sie `main.py`.

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Speichern Sie die `main.py`-Datei.

1. Erstellen Sie eine Beispielprotokolldatei. 

   1. Erstellen Sie im `multiline-app`-Ordner eine Datei und nennen Sie sie `test.log`.

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      panic: my panic
      
      goroutine 4 [running]:
      panic(0x45cb40, 0x47ad70)
        /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c
      main.main.func1(0xc420024120)
        foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1
      created by main.main
        foo.go:5 +0x58
      
      goroutine 1 [chan receive]:
      runtime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c
      runtime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e
      runtime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)
        /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4
      runtime.chanrecv1(0xc420024120, 0x0)
        /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b
      main.main()
        foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef
      runtime.main()
        /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1
      
      goroutine 2 [force gc (idle)]:
      runtime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c
      runtime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e
      runtime.forcegchelper()
        /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1
      created by runtime.init.4
        /usr/local/go/src/runtime/proc.go:227 +0x35
      
      goroutine 3 [GC sweep wait]:
      runtime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c
      runtime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e
      runtime.bgsweep(0xc42001e150)
        /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1
      created by runtime.gcenable
        /usr/local/go/src/runtime/mgc.go:216 +0x58
      one more line, no multiline
      ```

   1. Speichern Sie die `test.log`-Datei.

1. Erstellen Sie innerhalb des Ordners `multiline-app` die Docker-Datei.

   1. Fügen Sie den folgenden Inhalt in die Datei ein:

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Speichern Sie die `Dockerfile`-Datei.

1. Erstellen Sie mit der Dockerfile ein Image.

   1. Entwickeln Sie das Image: `docker build -t multiline-app-image `

      Wobei: `multiline-app-image` der Name für das Image in diesem Beispiel ist.

   1. Überprüfen Sie, ob das Image korrekt erstellt wurde: `docker images —filter reference=multiline-app-image` 

      Bei Erfolg zeigt die Ausgabe das Image und das `latest`-Tag.

1. Laden Sie das Image in Amazon-Elastic-Container-Registry hoch.

   1. Erstellen Sie ein Amazon-ECR-Repository zum Speichern des Images: `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Wobei: `multiline-app-repo` der Name für das Repository und `us-east-1` die Region in diesem Beispiel ist. 

      Die Ausgabe gibt Ihnen die Details des neuen Repositorys. Notieren Sie sich den `repositoryUri`-Wert, da Sie ihn in den nächsten Schritten benötigen. 

   1. Markieren Sie Ihr Image mit dem `repositoryUri`-Wert aus der vorherigen Ausgabe: `docker tag multiline-app-image repositoryUri` 

      Beispiel: `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Führen Sie das Docker-Image aus, um zu überprüfen, ob es korrekt ausgeführt wurde: `docker images —filter reference=repositoryUri`

      In der Ausgabe ändert sich der Repository-Name von `multiline-app-repo` in den `repositoryUri`-Wert.

   1. Verschieben Sie das Image zu Amazon ECR: `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Beispiel: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Erstellen einer Aufgabendefinition und Ausführen der Aufgabe**

1. Erstellen Sie eine Aufgabendefinitionsdatei mit dem Dateinamen `multiline-task-definition.json`. 

1. Fügen Sie den folgenden Inhalt in die `multiline-task-definition.json`-Datei ein: 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Ersetzen Sie Folgendes in der `multiline-task-definition.json`-Aufgabendefinition:

   1. `task role ARN`

      Um den Aufgabenrollen-ARN zu finden, gehen Sie zur IAM-Konsole. Wählen Sie **Roles** (Rollen) und suchen Sie die `ecs-task-role-for-firelens`-Aufgabenrolle, die Sie erstellt haben. Wählen Sie die Rolle aus und kopieren Sie den **ARN**, der im Abschnitt **Summary** (Zusammenfassung) angezeigt wird.

   1. `execution role ARN`

      Verwenden Sie die IAM-Konsole, um die Ausführungsrollen-ARN zu finden. Wählen Sie **Roles** (Rollen) aus und finden Sie die `ecsTaskExecutionRole`-Rolle. Wählen Sie die Rolle aus und kopieren Sie den **ARN**, der im Abschnitt **Summary** (Zusammenfassung) angezeigt wird.

   1. `aws_account_id`

      Um Ihr `aws_account_id` zu finden, melden Sie sich bei AWS-Managementkonsole an. Wählen Sie oben rechts Ihren Benutzernamen und kopieren Sie Ihre Konto-ID.

   1. `us-east-1`

      Ersetzen Sie die Region bei Bedarf.

1. Registrieren Sie die Aufgabendefinitionsdatei: `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region us-east-1` 

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** (Aufgabendefinitionen) und dann die `firelens-example-multiline`-Familie aus, da wir die Aufgabendefinition für diese Familie in der ersten Zeile der Aufgabendefinition oben registriert haben.

1. Wählen Sie die neueste Version aus. 

1. Wählen Sie **Bereitstellen**, **Aufgabe ausführen** aus. 

1. Wählen Sie auf der Seite **Task ausführen** für **Cluster** den Cluster aus, und wählen Sie dann unter **Netzwerk** für **Subnetze** die verfügbaren Subnetze für Ihre Aufgabe aus. 

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

**Stellen Sie sicher, dass mehrzeilige Protokollnachrichten in Amazon verkettet CloudWatch angezeigt werden**

1. Öffnen Sie die Konsole unter. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Erweitern Sie im Navigationsbereich **Logs** (Protokolle) und wählen Sie **Log groups** (Protokollgruppen) aus. 

1. Wählen Sie die Protokollgruppe `multiline-test/applicatio` aus. 

1. Wählen Sie das Protokoll aus und sehen Sie sich die Nachrichten an. Zeilen, die mit den Regeln in der Parser-Datei übereinstimmen, werden verkettet und werden als einzelne Nachricht angezeigt. 

   Das folgende Protokoll-Snippet zeigt einen Go-Stack-Trace, der zu einem einzigen Ereignis verkettet ist: 

   ```
   {
       "log": "panic: my panic\n\ngoroutine 4 [running]:\npanic(0x45cb40, 0x47ad70)\n  /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c\nmain.main.func1(0xc420024120)\n  foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1\ncreated by main.main\n  foo.go:5 +0x58\n\ngoroutine 1 [chan receive]:\nruntime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c\nruntime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e\nruntime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)\n  /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4\nruntime.chanrecv1(0xc420024120, 0x0)\n  /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b\nmain.main()\n  foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef\nruntime.main()\n  /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1\n\ngoroutine 2 [force gc (idle)]:\nruntime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c\nruntime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e\nruntime.forcegchelper()\n  /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1\ncreated by runtime.init.4\n  /usr/local/go/src/runtime/proc.go:227 +0x35\n\ngoroutine 3 [GC sweep wait]:\nruntime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c\nruntime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e\nruntime.bgsweep(0xc42001e150)\n  /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1\ncreated by runtime.gcenable\n  /usr/local/go/src/runtime/mgc.go:216 +0x58",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   Das folgende Protokoll-Snippet zeigt, wie dasselbe Ereignis angezeigt wird, wenn Sie einen ECS-Container ausführen, der nicht für die Verkettung von mehrzeiligen Protokollmeldungen konfiguriert ist. Das Protokollfeld enthält eine einzelne Zeile.

   ```
   {
       "log": "panic: my panic",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   ```

**Anmerkung**  
Wenn Ihre Protokolle anstelle der Standardausgabe in Protokolldateien gehen, empfehlen wir, die `multiline.parser`- und `multiline.key_content`-Konfigurationsparameter im [Tail-Eingabe-Plug-In](https://docs.fluentbit.io/manual/pipeline/inputs/tail#multiline-support) anstelle des Filters anzugeben.

# Bereitstellen von Fluent Bit in Amazon-ECS-Windows-Containers
<a name="tutorial-deploy-fluentbit-on-windows"></a>

Fluent Bit ist ein schneller und flexibler Protokollprozessor und Router, der von verschiedenen Betriebssystemen unterstützt wird. Es kann verwendet werden, um Protokolle an verschiedene AWS Ziele wie Amazon CloudWatch Logs, Firehose Amazon S3 und Amazon OpenSearch Service weiterzuleiten. Fluent Bit unterstützt gängige Partnerlösungen wie [Datadog](https://www.datadoghq.com/), [Splunk](https://www.splunk.com/) und benutzerdefinierte HTTP-Server. Weitere Informationen zu Fluent Bit finden Sie auf der [https://fluentbit.io/](https://fluentbit.io/)-Website.

Das **AWS -for-Fluent-Bit**-Image ist in Amazon ECR sowohl in der Amazon ECR Public Gallery als auch in einem Amazon-ECR-Repository in den meisten Regionen für hohe Verfügbarkeit verfügbar. Weitere Informationen finden Sie [https://github.com/aws/aws-for-fluent-bit](https://github.com/aws/aws-for-fluent-bit)auf der GitHub Website.

In diesem Tutorial erfahren Sie, wie Sie Fluent Bit-Container auf ihren Windows-Instances bereitstellen, die in Amazon ECS ausgeführt werden, um von den Windows-Aufgaben generierte Protokolle CloudWatch zur zentralen Protokollierung an Amazon zu streamen. 

Dieses Tutorial verwendet den folgenden Ansatz:
+ Fluent Bit wird als Service mit der Daemon-Planungstrategie ausgeführt. Diese Strategie stellt sicher, dass eine einzelne Instance von Fluent Bit immer auf den Container-Instances im Cluster ausgeführt wird.
  + Überwacht Port 24224 mithilfe des Weiterleitungs-Eingabe-Plugins.
  + Stellen Sie Port 24224 für den Host bereit, damit die Docker-Laufzeit über diesen bereitgestellten Port Protokolle an Fluent Bit senden kann.
  + Verfügt über eine Konfiguration, die es Fluent Bit ermöglicht, die Protokolldatensätze an bestimmte Ziele zu senden.
+ Starten Sie alle anderen Amazon-ECS-Aufgaben-Container mit dem Fluentd-Protokollierungstreiber. Weitere Informationen finden Sie unter [Fluentd-Protokollierungstreiber](https://docs.docker.com/engine/logging/drivers/fluentd/) auf der Website der Docker-Dokumentation.
  + Docker stellt eine Verbindung zum TCP-Socket 24224 auf localhost innerhalb des Host-Namespace her.
  + Der Amazon-ECS-Agent fügt den Containern Labels hinzu, die den Cluster-Namen, den Familiennamen der Aufgabendefinition, die Revisionsnummer der Aufgabendefinition, den ARN der Aufgabe und den Containernamen enthalten. Die gleichen Informationen werden dem Protokolldatensatz mithilfe der Labels-Option des Fluentd-Docker-Protokollierungstreibers hinzugefügt. Weitere Informationen finden Sie unter [labels, labels-regex, env und env-regex](https://docs.docker.com/config/containers/logging/fluentd/#labels-labels-regex-env-and-env-regex) auf der Website der Docker-Dokumentation.
  + Da die `async`-Option des Fluentd-Protokollierungstreibers auf `true` festgelegt ist, puffert Docker beim Neustart des Fluent-Bit-Containers die Protokolle, bis der Fluent-Bit-Container neu gestartet wird. Sie können das Pufferlimit erhöhen, indem Sie die fluentd-buffer-limit Option festlegen. Weitere Informationen finden Sie [fluentd-buffer-limit](https://docs.docker.com/config/containers/logging/fluentd/#fluentd-buffer-limit)auf der Docker-Dokumentationswebsite.

 Der Arbeitsablauf ist wie folgt:
+ Der Fluent-Bit-Container startet und überwacht auf Port 24224, der für den Host bereitgestellt ist.
+ Fluent Bit verwendet die in der Aufgabendefinition angegebenen IAM-Rollen-Anmeldeinformationen.
+ Andere Aufgaben, die auf derselben Instance gestartet werden, verwenden den Fluentd-Docker-Protokollierungstreiber, um eine Verbindung zum Fluent-Bit-Container auf Port 24224 herzustellen. 
+ Wenn die Anwendungscontainer Protokolle generieren, markiert die Docker-Laufzeit diese Datensätze, fügt zusätzliche in Labels angegebene Metadaten hinzu und leitet sie dann an Port 24224 im Host-Namespace weiter. 
+ Fluent Bit empfängt den Protokolldatensatz auf Port 24224, da dieser für den Host-Namespace bereitgestellt ist.
+ Fluent Bit führt seine interne Verarbeitung durch und leitet die Protokolle wie angegeben weiter.

In diesem Tutorial wird die CloudWatch Fluent Bit-Standardkonfiguration verwendet, die Folgendes bewirkt:
+ Erstellt eine neue Protokollgruppe für jeden Cluster und jede Aufgabendefinitionsfamilie.
+ Erstellt einen neuen Protokollstream für jeden Aufgaben-Container in der oben generierten Protokollgruppe, wenn eine neue Aufgabe gestartet wird. Jeder Stream wird mit der Aufgaben-ID gekennzeichnet, zu der der Container gehört.
+ Fügt zusätzliche Metadaten hinzu, einschließlich Cluster-Name, Aufgaben-ARN, Aufgaben-Containername, Aufgabendefinitionsfamilie und Revisionsnummer der Aufgabendefinition in jedem Protokolleintrag.

  Wenn Sie beispielsweise with `container_1` and `container_2` und t `task_1` `ask_2` with haben`container_3`, dann sind die CloudWatch Log-Streams im Folgenden aufgeführt:
  + `/aws/ecs/windows.ecs_task_1`

    `task-out.TASK_ID.container_1`

    `task-out.TASK_ID.container_2`
  + `/aws/ecs/windows.ecs_task_2`

    `task-out.TASK_ID.container_3`

**Anmerkung**  
Sie können Dual-Stack-Service-Endpunkte verwenden, um mit Amazon ECS über die AWS CLI SDKs, und die Amazon ECS-API sowohl über als auch IPv4 zu interagieren. IPv6 Weitere Informationen finden Sie unter [Verwenden von Dual-Stack-Endpunkten in Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [Voraussetzungen](#tutorial-deploy-fluentbit-on-windows-prereqs)
+ [Schritt 1: Erstellen der IAM-Zugriffsrollen](#tutorial-deploy-fluentbit-on-windows-iam-access-role)
+ [Schritt 2: Erstellen der Amazon-ECS-Windows-Container-Instance](#tutorial-deploy-fluentbit-on-windows-instance)
+ [Schritt 3: Konfigurieren von Fluent Bit](#tutorial-deploy-fluentbit-on-windows-configure-fluentbit)
+ [Schritt 4: Registrieren Sie eine Windows Fluent Bit-Aufgabendefinition, an die die Protokolle weitergeleitet werden CloudWatch](#tutorial-deploy-fluentbit-on-windows-register-task-definition)
+ [Schritt 5: Ausführen der `ecs-windows-fluent-bit`-Aufgabendefinition als Amazon-ECS-Service mithilfe der Daemon-Planungsstrategie](#tutorial-deploy-fluentbit-on-windows-run-task)
+ [Schritt 6: Registrieren einer Windows-Aufgabendefinition, die die Protokolle generiert](#tutorial-deploy-fluentbit-on-windows-register-task-def-logs)
+ [Schritt 7: Ausführen der `windows-app-task`-Aufgabendefinition](#tutorial-deploy-fluentbit-on-windows-run-task-fluentbit)
+ [Schritt 8: Überprüfen Sie die Anmeldung CloudWatch](#tutorial-deploy-fluentbit-on-windows-verify)
+ [Schritt 9: Bereinigen](#tutorial-deploy-fluentbit-on-windows-cleanup)

## Voraussetzungen
<a name="tutorial-deploy-fluentbit-on-windows-prereqs"></a>

In diesem Tutorial wird davon ausgegangen, dass die folgenden Voraussetzungen erfüllt wurden:
+ Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen finden Sie unter [Installieren oder Aktualisierung auf die neueste Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Das `aws-for-fluent-bit`-Container-Image ist für die folgenden Windows-Betriebssysteme verfügbar:
  + Windows Server 2019 Core
  + Windows Server 2019 Full
  + Windows Server 2022 Kern
  + Windows Server 2022 Voll
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Sie verfügen über einen Cluster. In diesem Tutorial lautet der Clustername **FluentBit-cluster**.
+ Sie verfügen über eine VPC mit einem öffentlichen Subnetz, in dem die EC2-Instance gestartet werden soll. Sie können Ihre Standard-VPC verwenden. Sie können auch ein privates Subnetz verwenden, das es CloudWatch Amazon-Endpunkten ermöglicht, das Subnetz zu erreichen. Weitere Informationen zu CloudWatch Amazon-Endpunkten finden Sie unter [ CloudWatch Amazon-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/cw_region.html) in der. *Allgemeine AWS-Referenz* Informationen zur Verwendung des Amazon-VPC-Assistenten zum Erstellen einer VPC finden Sie unter [Erstellen einer Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).

## Schritt 1: Erstellen der IAM-Zugriffsrollen
<a name="tutorial-deploy-fluentbit-on-windows-iam-access-role"></a>

Erstellen Sie die Amazon-IAM-Rollen.

1.  Erstellen Sie die Amazon ECS-Container-Instance-Rolle mit dem Namen "ecsInstanceRole“. Weitere Informationen finden Sie unter [IAM-Rolle der Amazon-ECS-Container-Instance](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html).

1. Erstellen Sie eine IAM-Rolle für die Fluent-Bit-Aufgabe mit dem Namen `fluentTaskRole`. Weitere Informationen finden Sie unter [Aufgaben-IAM-Rolle für Amazon ECS](task-iam-roles.md).

    Die in dieser IAM-Rolle gewährten IAM-Berechtigungen werden von den Aufgaben-Containern übernommen. Damit Fluent Bit Protokolle an senden kann CloudWatch, müssen Sie der Task-IAM-Rolle die folgenden Berechtigungen zuordnen.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
       {
           "Effect": "Allow",
           "Action": [
               "logs:CreateLogStream",
               "logs:CreateLogGroup",
               "logs:DescribeLogStreams",
               "logs:PutLogEvents"
           ],
           "Resource": "*"
       }
       ]
   }
   ```

------

1. Fügen Sie der Rolle die -Richtlinie an.

   1. Speichern Sie den obigen Inhalt in einer Datei mit dem Namen `fluent-bit-policy.json`.

   1. Führen Sie den folgenden Befehl aus, um die Inline-Richtlinie der `fluentTaskRole`-IAM-Rolle anzufügen.

      ```
      aws iam put-role-policy --role-name fluentTaskRole --policy-name fluentTaskPolicy --policy-document file://fluent-bit-policy.json
      ```

## Schritt 2: Erstellen der Amazon-ECS-Windows-Container-Instance
<a name="tutorial-deploy-fluentbit-on-windows-instance"></a>

Erstellen Sie eine Windows-Container-Instance für Amazon ECS.

**So erstellen Sie eine Amazon-ECS-Instance**

1. Verwenden Sie den `aws ssm get-parameters`-Befehl, um die AMI-ID für die Region abzurufen, in der Ihre VPC gehostet wird. Weitere Informationen finden Sie unter [Abrufen von Amazon-ECS-optimierten AMI-Metadaten](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/retrieve-ecs-optimized_windows_AMI.html).

1. Verwenden Sie die Amazon-EC2-Konsole, um die Instance zu starten.

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

   1. Wählen Sie die zu verwendende Region in der Navigationsleiste aus.

   1. Wählen Sie im **EC2-Dashboard** **Launch Instance (Instance starten)** aus.

   1. Geben Sie für **Name** einen eindeutigen Namen ein.

   1. Wählen Sie für **Application and OS Images (Amazon Machine Image)** (Anwendungs- und Betriebssystem-Images (Amazon-Computer-Image)) das AMI aus, das Sie im ersten Schritt abgerufen haben.

   1. Wählen Sie für **Instance type** die Option `t3.xlarge` aus.

   1. Wählen Sie für **Key pair (login)** (Schlüsselpaar (Anmeldung)) ein Schlüsselpaar aus. 

   1. Wählen Sie unter **Network settings** (Netzwerkeinstellungen) für **Security group** (Sicherheitsgruppe) eine vorhandene Sicherheitsgruppe aus oder erstellen Sie eine neue.

   1. Wählen Sie unter **Network settings** (Netzwerkeinstellungen), für **Auto-assign Public IP** (Öffentliche IP automatisch zuweisen), die Option **Enable** (Aktivieren) aus. 

   1. Wählen Sie unter **Erweiterte Details** für das **IAM-Instanzprofil** die Option. **ecsInstanceRole**

   1. Konfigurieren Sie Ihre Amazon-ECS-Container-Instance mit den folgenden Benutzerdaten. Fügen Sie unter **Erweiterte Details** das folgende Skript in das Feld **Benutzerdaten** ein und *cluster\$1name* ersetzen Sie es durch den Namen Ihres Clusters.

      ```
      <powershell>
      Import-Module ECSTools
      Initialize-ECSAgent -Cluster cluster-name -EnableTaskENI -EnableTaskIAMRole -LoggingDrivers '["awslogs","fluentd"]'
      </powershell>
      ```

   1. Wenn Sie bereit sind, wählen Sie das Bestätigungsfeld und danach **Launch Instances** aus. 

   1. Auf einer Bestätigungsseite wird Ihnen mitgeteilt, dass die Instance gestartet wird. Wählen Sie **View Instances** aus, um die Bestätigungsseite zu schließen und zur Konsole zurückzukehren.

## Schritt 3: Konfigurieren von Fluent Bit
<a name="tutorial-deploy-fluentbit-on-windows-configure-fluentbit"></a>

Sie können die folgende Standardkonfiguration von verwenden AWS , um schnell loszulegen:
+ [Amazon CloudWatch](https://github.com/aws/aws-for-fluent-bit/blob/mainline/ecs_windows_forward_daemon/cloudwatch.conf), das auf dem Fluent Bit-Plug-In für [ CloudWatchAmazon](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch) im *offiziellen Fluent Bit-Handbuch* basiert.

Alternativ können Sie andere Standardkonfigurationen verwenden, die von bereitgestellt werden. AWS Weitere Informationen finden Sie unter [Überschreiben des Einstiegspunkts für das Windows-Image](https://github.com/aws/aws-for-fluent-bit/tree/mainline/ecs_windows_forward_daemon#overriding-the-entrypoint-for-the-windows-image) auf der `aws-for-fluent-bit`-Github-Website.

Die Standardkonfiguration von Amazon CloudWatch Fluent Bit ist unten dargestellt.

Ersetzen Sie die folgenden Variablen:
+ *region*mit der Region, in die Sie die CloudWatch Amazon-Protokolle senden möchten.

```
[SERVICE]
    Flush               5
    Log_Level           info
    Daemon              off

[INPUT]
    Name                forward
    Listen              0.0.0.0
    Port                24224
    Buffer_Chunk_Size   1M
    Buffer_Max_Size     6M
    Tag_Prefix          ecs.

# Amazon ECS agent adds the following log keys as labels to the docker container.
# We would use fluentd logging driver to add these to log record while sending it to Fluent Bit.
[FILTER]
    Name                modify
    Match               ecs.*
    Rename              com.amazonaws.ecs.cluster ecs_cluster
    Rename              com.amazonaws.ecs.container-name ecs_container_name
    Rename              com.amazonaws.ecs.task-arn ecs_task_arn
    Rename              com.amazonaws.ecs.task-definition-family ecs_task_definition_family
    Rename              com.amazonaws.ecs.task-definition-version ecs_task_definition_version

[FILTER]
    Name                rewrite_tag
    Match               ecs.*
    Rule                $ecs_task_arn ^([a-z-:0-9]+)/([a-zA-Z0-9-_]+)/([a-z0-9]+)$  out.$3.$ecs_container_name false
    Emitter_Name        re_emitted

[OUTPUT]
    Name                cloudwatch_logs
    Match               out.*
    region              region
    log_group_name      fallback-group
    log_group_template  /aws/ecs/$ecs_cluster.$ecs_task_definition_family
    log_stream_prefix   task-
    auto_create_group   On
```

Jedes Protokoll, das in Fluent Bit eingeht, verfügt über ein Tag, das Sie angeben, oder wird automatisch generiert, wenn Sie keins angeben. Die Tags können verwendet werden, um verschiedene Protokolle an verschiedene Ziele weiterzuleiten. Weitere Informationen finden Sie unter [Tag](https://docs.fluentbit.io/manual/concepts/key-concepts#tag) im *offiziellen Fluent-Bit-Handbuch*. 

Die oben beschriebene Fluent-Bit-Konfiguration hat die folgenden Eigenschaften:
+ Das Weiterleitungs-Eingabe-Plugin überwacht auf eingehendem Datenverkehr auf TCP-Port 24224. 
+ Jeder an diesem Port empfangene Protokolleintrag verfügt über ein Tag, das das Weiterleitungs-Eingabe-Plugin ändert, um dem Datensatz eine `ecs.`-Zeichenfolge voranzustellen. 
+ Die interne Fluent-Bit-Pipeline leitet den Protokolleintrag weiter, um den Filter mithilfe des regulären Ausdrucks „Match“ zu ändern. Dieser Filter ersetzt die Schlüssel im JSON-Protokolldatensatz durch das Format, das Fluent Bit verarbeiten kann. 
+ Der geänderte Protokolleintrag wird dann vom rewrite\$1tag-Filter verarbeitet. Dieser Filter ändert das Tag des Protokolldatensatzes auf das Ausgangsformat. *TASK\$1ID*. *CONTAINER\$1NAME*. 
+ Das neue Tag wird an das Output-Plug-In cloudwatch\$1logs weitergeleitet, das die Protokollgruppen und Streams wie zuvor beschrieben mithilfe der `log_stream_prefix` Optionen `log_group_template` und des Ausgabe-Plug-ins erstellt. CloudWatch Weitere Informationen finden Sie unter [Konfigurationsparameter](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch#configuration-parameters) im *offiziellen Fluent-Bit-Handbuch*. 

## Schritt 4: Registrieren Sie eine Windows Fluent Bit-Aufgabendefinition, an die die Protokolle weitergeleitet werden CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-register-task-definition"></a>

Registrieren Sie eine Windows Fluent Bit-Aufgabendefinition, an die die Protokolle weitergeleitet werden. CloudWatch

**Anmerkung**  
Diese Aufgabendefinition stellt den Fluent Bit-Container-Port 24224 für den Host-Port 24224 bereit. Stellen Sie sicher, dass dieser Port nicht in Ihrer EC2-Instance-Sicherheitsgruppe geöffnet ist, um externen Zugriff zu verhindern.

**So registrieren Sie eine Aufgabendefinition**

1. Erstellen Sie eine Datei mit dem Namen `fluent-bit.json` und dem folgenden Inhalt.

   Ersetzen Sie die folgenden Variablen:
   + *task-iam-role*mit dem Amazon-Ressourcennamen (ARN) Ihrer Task-IAM-Rolle
   + *region*mit der Region, in der Ihre Aufgabe ausgeführt wird

   ```
   {
     "family": "ecs-windows-fluent-bit",
     "taskRoleArn": "task-iam-role",
     "containerDefinitions": [
       {
         "name": "fluent-bit",
         "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-latest",
         "cpu": 512,
         "portMappings": [
           {
             "hostPort": 24224,
             "containerPort": 24224,
             "protocol": "tcp"
           }
         ],
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "C:\\entrypoint.ps1 -ConfigFile C:\\ecs_windows_forward_daemon\\cloudwatch.conf"
         ],
         "environment": [
           {
             "name": "AWS_REGION",
             "value": "region"
           }
         ],
         "memory": 512,
         "essential": true,
         "logConfiguration": {
           "logDriver": "awslogs",
           "options": {
             "awslogs-group": "/ecs/fluent-bit-logs",
             "awslogs-region": "region",
             "awslogs-stream-prefix": "flb",
             "awslogs-create-group": "true"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Führen Sie den folgenden Befehl aus, um die Aufgabendefinition zu registrieren.

   ```
   aws ecs register-task-definition --cli-input-json file://fluent-bit.json --region region
   ```

   Sie können die Aufgabendefinitionen für Ihr Konto auflisten, indem Sie den `list-task-definitions`-Befehl ausführen. Die Ausgabe zeigt die Familien- und Revisionswerte an, die Sie zusammen mit `run-task` oder `start-task` verwenden können.

## Schritt 5: Ausführen der `ecs-windows-fluent-bit`-Aufgabendefinition als Amazon-ECS-Service mithilfe der Daemon-Planungsstrategie
<a name="tutorial-deploy-fluentbit-on-windows-run-task"></a>

Nachdem Sie eine Aufgabendefinition für Ihr Konto registriert haben, können Sie eine Aufgabe im Cluster ausführen. Für dieses Tutorial führen Sie eine Instance der `ecs-windows-fluent-bit:1`-Aufgabendefinition in Ihrem `FluentBit-cluster`-Cluster aus. Führen Sie die Aufgabe in einem Service aus, der die Daemon-Planungsstrategie verwendet, die sicherstellt, dass auf jeder Ihrer Container-Instances immer eine einzige Instance von Fluent Bit ausgeführt wird.

**Ausführen einer Aufgabe**

1. Führen Sie den folgenden Befehl aus, um die `ecs-windows-fluent-bit:1`-Aufgabendefinition (im vorherigen Schritt registriert) als Service zu starten.
**Anmerkung**  
Diese Aufgabendefinition verwendet den `awslogs`-Protokollierungstreiber. Ihre Container Instance muss über die erforderlichen Berechtigungen verfügen.

   Ersetzen Sie die folgenden Variablen:
   + *region*mit der Region, in der Ihr Dienst ausgeführt wird

   ```
   aws ecs create-service \
       --cluster FluentBit-cluster \
       --service-name FluentBitForwardDaemonService \
       --task-definition ecs-windows-fluent-bit:1 \
       --launch-type EC2 \
       --scheduling-strategy DAEMON \
       --region region
   ```

1. Führen Sie den folgenden Befehl aus, um Ihre Aufgaben aufzulisten.

   Ersetzen Sie die folgenden Variablen:
   + *region*mit der Region, in der Ihre Serviceaufgaben ausgeführt werden

   ```
   aws ecs list-tasks --cluster FluentBit-cluster --region region
   ```

## Schritt 6: Registrieren einer Windows-Aufgabendefinition, die die Protokolle generiert
<a name="tutorial-deploy-fluentbit-on-windows-register-task-def-logs"></a>

Registrieren Sie eine Aufgabendefinition, die die Protokolle generiert. Diese Aufgabendefinition stellt ein Windows-Container-Image bereit, das jede Sekunde eine inkrementelle Zahl in `stdout` schreibt.

Die Aufgabendefinition verwendet den Fluentd-Protokollierungstreiber, der eine Verbindung zu Port 24224 herstellt, den das Fluent-Bit-Plugin überwacht. Der Amazon-ECS-Agent kennzeichnet jeden Amazon-ECS-Container mit Tags, einschließlich Cluster-Name, Aufgaben-ARN, Familienname der Aufgabendefinition, Revisionsnummer der Aufgabendefinition und Name des Aufgaben-Containers. Diese Schlüsselwert-Labels werden an Fluent Bit übermittelt.

**Anmerkung**  
Diese Aufgabe verwendet den `default`-Netzwerkmodus. Sie können jedoch auch den `awsvpc`-Netzwerkmodus mit der Aufgabe verwenden.

**So registrieren Sie eine Aufgabendefinition**

1. Erstellen Sie eine Datei mit dem Namen `windows-app-task.json` und dem folgenden Inhalt.

   ```
   {
     "family": "windows-app-task",
     "containerDefinitions": [
       {
         "name": "sample-container",
         "image": "mcr.microsoft.com/windows/servercore:ltsc2019",
         "cpu": 512,
         "memory": 512,
         "essential": true,
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "$count=1;while(1) { Write-Host $count; sleep 1; $count=$count+1;}"
         ],
         "logConfiguration": {
           "logDriver": "fluentd",
           "options": {
             "fluentd-address": "localhost:24224",
             "tag": "{{ index .ContainerLabels \"com.amazonaws.ecs.task-definition-family\" }}",
             "fluentd-async": "true",
             "labels": "com.amazonaws.ecs.cluster,com.amazonaws.ecs.container-name,com.amazonaws.ecs.task-arn,com.amazonaws.ecs.task-definition-family,com.amazonaws.ecs.task-definition-version"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Führen Sie den folgenden Befehl aus, um die Aufgabendefinition zu registrieren.

   Ersetzen Sie die folgenden Variablen:
   + *region*mit der Region, in der Ihre Aufgabe ausgeführt wird

   ```
   aws ecs register-task-definition --cli-input-json file://windows-app-task.json --region region
   ```

   Sie können die Aufgabendefinitionen für Ihr Konto auflisten, indem Sie den `list-task-definitions`-Befehl ausführen. Die Ausgabe zeigt die Familien- und Revisionswerte an, die Sie zusammen mit `run-task` oder `start-task` verwenden können.

## Schritt 7: Ausführen der `windows-app-task`-Aufgabendefinition
<a name="tutorial-deploy-fluentbit-on-windows-run-task-fluentbit"></a>

Nachdem Sie die `windows-app-task`-Aufgabendefinition registriert haben, führen Sie sie in Ihrem `FluentBit-cluster`-Cluster aus.

**Ausführen einer Aufgabe**

1. Führen Sie die `windows-app-task:1`-Aufgabendefinition aus, die Sie im vorherigen Schritt registriert haben.

   Ersetzen Sie die folgenden Variablen:
   + *region*mit der Region, in der Ihre Aufgabe ausgeführt wird

   ```
   aws ecs run-task --cluster FluentBit-cluster --task-definition windows-app-task:1 --count 2 --region region
   ```

1. Führen Sie den folgenden Befehl aus, um Ihre Aufgaben aufzulisten.

   ```
   aws ecs list-tasks --cluster FluentBit-cluster
   ```

## Schritt 8: Überprüfen Sie die Anmeldung CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-verify"></a>

Um Ihr Fluent Bit-Setup zu überprüfen, suchen Sie in der CloudWatch Konsole nach den folgenden Protokollgruppen:
+ `/ecs/fluent-bit-logs` – Dies ist die Protokollgruppe, die dem Fluent-Bit-Daemon-Container entspricht, der auf der Container-Instance ausgeführt wird.
+ `/aws/ecs/FluentBit-cluster.windows-app-task` – Dies ist die Protokollgruppe, die allen Aufgaben entspricht, die für die `windows-app-task`-Aufgabendefinitionsfamilie innerhalb des `FluentBit-cluster`-Clusters gestartet wurden.

   `task-out.FIRST_TASK_ID.sample-container` – Dieser Protokollstream enthält alle Protokolle, die von der ersten Instance der Aufgabe im Beispielcontainer bzw. Aufgaben-Container generiert wurden. 

  `task-out.SECOND_TASK_ID.sample-container` – Dieser Protokollstream enthält alle Protokolle, die von der zweiten Instance der Aufgabe im Beispielcontainer bzw. Aufgaben-Container generiert wurden. 

 Der `task-out.TASK_ID.sample-container`-Protokollstream hat Felder, die den folgenden ähneln:

```
{
    "source": "stdout",
    "ecs_task_arn": "arn:aws:ecs:region:0123456789012:task/FluentBit-cluster/13EXAMPLE",
    "container_name": "/ecs-windows-app-task-1-sample-container-cEXAMPLE",
    "ecs_cluster": "FluentBit-cluster",
    "ecs_container_name": "sample-container",
    "ecs_task_definition_version": "1",
    "container_id": "61f5e6EXAMPLE",
    "log": "10",
    "ecs_task_definition_family": "windows-app-task"
}
```

**So überprüfen Sie die Fluent-Bit-Einrichtung**

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 **Protokollgruppen** aus. Stellen Sie sicher, dass Sie sich in der Region befinden, in der Sie Fluent Bit für Ihre Container bereitgestellt haben.

   In der Liste der Protokollgruppen in der AWS-Region sollten Sie Folgendes sehen:
   + `/ecs/fluent-bit-logs`
   + `/aws/ecs/FluentBit-cluster.windows-app-task`

   Wenn Sie diese Protokollgruppen sehen, wurde die Fluent-Bit-Einrichtung verifiziert.

## Schritt 9: Bereinigen
<a name="tutorial-deploy-fluentbit-on-windows-cleanup"></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. 

**So bereinigen Sie die Tutorial-Ressourcen**

1. Halten Sie die `windows-simple-task`-Aufgabe und die `ecs-fluent-bit`-Aufgabe an. Weitere Informationen finden Sie unter [Beenden einer Amazon-ECS-Aufgabe](standalone-task-stop.md).

1. Verwenden Sie den folgenden Befehl, um die `/ecs/fluent-bit-logs`-Protokollgruppe zu löschen. Weitere Informationen zum Löschen von Protokollgruppen finden Sie [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html)in der *AWS Command Line Interface Referenz*.

   ```
   aws logs delete-log-group --log-group-name /ecs/fluent-bit-logs
   aws logs delete-log-group --log-group-name /aws/ecs/FluentBit-cluster.windows-app-task
   ```

1. Führen Sie den folgenden Befehl aus, um die Instance zu beenden.

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

1. Führen Sie den folgenden Befehl aus, um die IAM-Rollen zu löschen. 

   ```
   aws iam delete-role --role-name ecsInstanceRole
   aws iam delete-role --role-name fluentTaskRole
   ```

1. Führen Sie den folgenden Befehl aus, um den Amazon-ECS-Cluster zu löschen.

   ```
   aws ecs delete-cluster --cluster FluentBit-cluster
   ```

# Verwendung von gMSA für EC2-Linux-Container in Amazon ECS
<a name="linux-gmsa"></a>

Amazon ECS unterstützt die Active-Directory-Authentifizierung für Linux-Container in EC2 über ein spezielles Service-Konto namens *group Managed Service Account* (gMSA).

Linux-basierte Netzwerkanwendungen wie .NET-Core-Anwendungen können Active Directory verwenden, um die Authentifizierung und Autorisierung zwischen Benutzern und Services zu verwalten. Sie können dieses Feature nutzen, indem Sie Anwendungen entwickeln, die mit Active Directory integriert sind und auf Domain-verbundenen Servern laufen. Da Linux-Container jedoch nicht mit einer Domain verbunden werden können, müssen Sie einen Linux-Container für die Ausführung mit gMSA konfigurieren.

Ein Linux-Container, der mit gMSA ausgeführt wird, stützt sich auf den `credentials-fetcher`-Daemon, der auf der Amazon-EC2-Host-Instance des Containers läuft. Das heißt, der Daemon ruft die gMSA-Anmeldeinformationen vom Active Directory-Domain-Controller ab und überträgt diese Anmeldeinformationen an die Container-Instance. Weitere Informationen zu Servicekonten finden Sie unter [gMSAs für Windows-Container erstellen](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts) auf der Microsoft-Learn-Website.

## Überlegungen
<a name="linux-gmsa-considerations"></a>

Beachten Sie Folgendes, bevor Sie gMSA für Linux-Container verwenden:
+ Wenn Ihre Container auf EC2 ausgeführt werden, können Sie sie gMSA für Windows-Container und Linux-Container verwenden. Informationen zur Verwendung von gMSA für Linux-Container in Fargate finden Sie unter [Verwendung von gMSA für Linux-Container in Fargate](fargate-linux-gmsa.md).
+ Möglicherweise benötigen Sie einen Windows-Computer, der mit der Domain verbunden ist, um die Voraussetzungen zu erfüllen. Beispielsweise benötigen Sie möglicherweise einen Windows-Computer, welcher mit der Domain verbunden ist, um die gMSA in Active Directory mit PowerShell zu erstellen. Die RSAT Active PowerShell Director-Tools sind nur für verfügbarWindows. Weitere Informationen finden Sie unter [Installieren der Active-Directory-Verwaltungstools](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html).
+ Sie haben zwischen **domainlose gMSA** und **Hinzufügen jeder Instance zu einer einzelnen Domain** gewählt. Durch die Verwendung von domainlosen gMSA ist die Container-Instance nicht mit der Domain verbunden, andere Anwendungen auf der Instance können die Anmeldeinformationen nicht verwenden, um auf die Domain zuzugreifen, und Aufgaben, die verschiedenen Domains angehören, können auf derselben Instance ausgeführt werden.

  Wählen Sie dann den Datenspeicher für CredSpec und optional für die Active-Directory-Benutzeranmeldeinformationen für domainlose gMSA.

  Amazon ECS verwendet eine Spezifikationsdatei für Active-Directory-Anmeldeinformationen (CredSpec). Diese Datei enthält die gMSA-Metadaten, die verwendet werden, um den gMSA-Kontokontext an den Container weiterzuleiten. Sie generieren die CredSpec-Datei und speichern sie dann in einer der CredSpec-Speicheroptionen in der folgenden Tabelle, die für das Betriebssystem der Container-Instances spezifisch sind. Um die domainlose Methode zu verwenden, kann ein optionaler Abschnitt in der CredSpec-Datei Anmeldeinformationen in einer der *domainless user credentials*-Speicheroptionen in der folgenden Tabelle angeben, die für das Betriebssystem der Container-Instances spezifisch sind.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonECS/latest/developerguide/linux-gmsa.html)

## Voraussetzungen
<a name="linux-gmsa-prerequisites"></a>

Bevor Sie das gMSA-Feature für Linux-Container mit Amazon ECS verwenden, müssen Sie folgende Schritte ausführen:
+ Sie richten eine Active-Directory-Domain mit den Ressourcen ein, auf die Ihre Container zugreifen sollen. Amazon ECS unterstützt die folgenden Einrichtungen:
  + Ein Directory Service Active Directory. Directory Service ist ein AWS verwaltetes Active Directory, das auf Amazon EC2 gehostet wird. Weitere Informationen finden Sie unter [Erste Schritte mit AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) im *AWS Directory Service Administratorhandbuch*.
  + Ein On-Premises-Active-Directory. Sie müssen sicherstellen, dass die Container-Instance von Amazon ECS Linux der Domain beitreten kann. Weitere Informationen finden Sie unter [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect.html).
+ Sie haben ein bestehendes gMSA-Konto im Active Directory. Weitere Informationen finden Sie unter [Verwendung von gMSA für EC2-Linux-Container in Amazon ECS](#linux-gmsa).
+ Sie haben den `credentials-fetcher`-Daemon auf einer Container-Instance von Amazon ECS Linux installiert und führen ihn dort aus. Sie haben dem `credentials-fetcher`-Daemon auch einen ersten Satz von Anmeldeinformationen hinzugefügt, um sich mit dem Active Directory zu authentifizieren.
**Anmerkung**  
Der `credentials-fetcher`-Daemon ist nur für Amazon Linux 2023 und Fedora 37 und höher verfügbar. Der Daemon ist für Amazon Linux 2 nicht verfügbar. Weitere Informationen finden Sie unter [aws/credentials](https://github.com/aws/credentials-fetcher) fetcher on. GitHub
+ Sie richten die Anmeldeinformationen für den `credentials-fetcher`-Daemon ein, um sich mit dem Active Directory zu authentifizieren. Die Anmeldeinformationen müssen Mitglied der Active-Directory-Sicherheitsgruppe sein, die Zugriff auf das gMSA-Konto hat. Es gibt mehrere Optionen in [Entscheiden Sie, ob Sie die Instances mit der Domain verbinden oder domainlose gMSA verwenden möchten.](#linux-gmsa-initial-creds).
+ Sie haben die erforderlichen IAM-Berechtigungen hinzugefügt. Welche Berechtigungen erforderlich sind, hängt von den Methoden ab, die Sie für die anfänglichen Anmeldeinformationen und für die Speicherung der Anmeldeinformation wählen:
  + Wenn Sie *Domainless gMSA* für anfängliche Anmeldeinformationen verwenden, sind IAM-Berechtigungen für für die Aufgabenausführungsrolle erforderlich. AWS Secrets Manager 
  + Wenn Sie die Spezifikation der Anmeldeinformationen im SSM Parameter Store speichern, sind IAM-Berechtigungen für den Amazon EC2 Systems Manager Parameter Store für die Rolle der Aufgabenausführung erforderlich.
  + Wenn Sie die Spezifikation der Anmeldeinformationen in Amazon S3 speichern, sind IAM-Berechtigungen für Amazon Simple Storage Service für die Rolle der Aufgabenausführung erforderlich.

## Einrichten von gMSA-fähigen Linux-Containern unter Amazon ECS
<a name="linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Die Infrastruktur vorbereiten**  
Bei den folgenden Schritten handelt es sich um Überlegungen und Einstellungen, die einmal durchgeführt werden müssen. Nachdem Sie diese Schritte ausgeführt haben, können Sie die Erstellung von Container-Instances automatisieren, um diese Konfiguration wiederzuverwenden.

Entscheiden Sie, wie die anfänglichen Anmeldeinformationen bereitgestellt werden, und konfigurieren Sie die EC2-Benutzerdaten in einer wiederverwendbaren EC2-Startvorlage, um den `credentials-fetcher`-Daemon zu installieren.

1. <a name="linux-gmsa-initial-creds"></a>

**Entscheiden Sie, ob Sie die Instances mit der Domain verbinden oder domainlose gMSA verwenden möchten.**
   + <a name="linux-gmsa-initial-join"></a>

**EC2-Instances mit der Active Directory-Domain verbinden**

     
     + <a name="linux-gmsa-initial-join-userdata"></a>

**Die Instances anhand von Benutzerdaten hinzufügen**

       Fügen Sie die Schritte zum Verbinden der Active-Directory-Domain mit Ihren EC2-Benutzerdaten in eine EC2-Startvorlage ein. Mehrere Gruppen von Amazon EC2 Auto Scaling können dieselbe Startvorlage verwenden.

       Sie können diese Schritte in den Fedora Docs zum [Beitreten zu einem Active Directory oder einer FreeIPA-Domain](https://docs.fedoraproject.org/en-US/quick-docs/join-active-directory-freeipa/) verwenden.
   + <a name="linux-gmsa-initial-domainless"></a>

**Erstellen Sie einen Active-Directory-Benutzer für domainlose gMSA**

     *Der `credentials-fetcher`-Daemon verfügt über ein Feature, die als domainlose gMSA bezeichnet wird.* Für dieses Feature ist eine Domain erforderlich, die EC2-Instance muss jedoch nicht mit der Domain verbunden werden. Durch die Verwendung von domainlosen gMSA ist die Container-Instance nicht mit der Domain verbunden, andere Anwendungen auf der Instance können die Anmeldeinformationen nicht verwenden, um auf die Domain zuzugreifen, und Aufgaben, die verschiedenen Domains angehören, können auf derselben Instance ausgeführt werden. Stattdessen geben Sie den Namen eines Secrets in AWS Secrets Manager in der CredSpec-Datei an. Das Secret muss einen Benutzernamen, ein Passwort und die Domain enthalten, bei der die Anmeldung erfolgen soll.

     Dieses Feature wird unterstützt und kann mit Linux- und Windows-Containern verwendet werden.

     Dieses Feature ähnelt dem *gMSA support for non-domain-joined container hosts*-Feature. Weitere Informationen zum Windows-Feature finden Sie unter [gMSA-Architektur und -Verbesserungen](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) auf der Microsoft-Learn-Website.

     1. Erstellen Sie einen Benutzer in Ihrer Active-Directory-Domain. Der Benutzer in Active Directory muss berechtigt sein, auf die gMSA-Servicekonten zuzugreifen, die Sie für die Aufgaben verwenden.

     1. Erstellen Sie ein Geheimnis in AWS Secrets Manager, nachdem Sie den Benutzer in Active Directory erstellt haben. Weitere Informationen finden Sie unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

     1. Geben Sie den Benutzernamen, das Passwort und die Domain des Benutzers in JSON-Schlüssel-Wert-Paare mit den Bezeichnungen `username`, `password` bzw. `domainName`, ein.

        ```
        {"username":"username","password":"passw0rd", "domainName":"example.com"}
        ```

     1. Fügen Sie der CredSpec-Datei die Konfiguration für das Servicekonto hinzu. Der zusätzliche `HostAccountConfig` enthält den Amazon-Ressourcennamen (ARN) des Secrets in Secrets Manager.

        Auf Windows muss der `PluginGUID` mit der GUID im folgenden Beispielausschnitt übereinstimmen. Auf Linux wird der `PluginGUID` ignoriert. Ersetzen Sie `MySecret` zum Beispiel durch den Amazon-Ressourcennamen (ARN) Ihres Secrets.

        ```
            "ActiveDirectoryConfig": {
                "HostAccountConfig": {
                    "PortableCcgVersion": "1",
                    "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
                    "PluginInput": {
                        "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
                    }
                }
        ```

     1. Für das Feature *domainlose gMSA* sind zusätzliche Berechtigungen in der Aufgabenausführungsrolle erforderlich. Folgen Sie dem Schritt [(Optional) domainloses gMSA-Secret](#linux-gmsa-domainless-secret).

1. <a name="linux-gmsa-install"></a>

**Instances und installieren Sie den `credentials-fetcher`-Daemon konfigurieren**

   Sie können den `credentials-fetcher`-Daemon mit einem Benutzerdatenskript in Ihrer EC2-Startvorlage installieren. Die folgenden Beispiele veranschaulichen zwei Arten von Benutzerdaten `cloud-config` YAML oder bash-Skript. Diese Beispiele gelten für Amazon Linux 2023 (AL2023). Ersetzen Sie `MyCluster` durch den Namen des Amazon-ECS-Clusters, mit dem diese Instances verbunden werden sollen.
   + <a name="linux-gmsa-install-yaml"></a>

**`cloud-config` YAML**

     ```
     Content-Type: text/cloud-config
     package_reboot_if_required: true
     packages:
       # prerequisites
       - dotnet
       - realmd
       - oddjob
       - oddjob-mkhomedir
       - sssd
       - adcli
       - krb5-workstation
       - samba-common-tools
       # https://github.com/aws/credentials-fetcher gMSA credentials management for containers
       - credentials-fetcher
     write_files:
     # configure the ECS Agent to join your cluster.
     # replace MyCluster with the name of your cluster.
     - path: /etc/ecs/ecs.config
       owner: root:root
       permissions: '0644'
       content: |
         ECS_CLUSTER=MyCluster
         ECS_GMSA_SUPPORTED=true
     runcmd:
     # start the credentials-fetcher daemon and if it succeeded, make it start after every reboot
     - "systemctl start credentials-fetcher"
     - "systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher"
     ```
   + <a name="linux-gmsa-install-userdata"></a>

**bash-Skript**

     Wenn Sie sich mit bash-Skripten besser auskennen und mehrere Variablen in `/etc/ecs/ecs.config` zu schreiben haben, verwenden Sie das folgende `heredoc`-Format. Bei Verwendung dieses Formats wird alles zwischen den Zeilen **cat** und `EOF` in die Konfigurationsdatei geschrieben.

     ```
     #!/usr/bin/env bash
     set -euxo pipefail
     
     # prerequisites
     timeout 30 dnf install -y dotnet realmd oddjob oddjob-mkhomedir sssd adcli krb5-workstation samba-common-tools
     # install https://github.com/aws/credentials-fetcher gMSA credentials management for containers
     timeout 30 dnf install -y credentials-fetcher
     
     # start credentials-fetcher
     systemctl start credentials-fetcher
     systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher
     
     cat <<'EOF' >> /etc/ecs/ecs.config
     ECS_CLUSTER=MyCluster
     ECS_GMSA_SUPPORTED=true
     EOF
     ```

   Es gibt optionale Konfigurationsvariablen für den `credentials-fetcher`-Daemon, die Sie in `/etc/ecs/ecs.config` einrichten können. Wir empfehlen, dass Sie die Variablen in den Benutzerdaten im YAML-Block oder `heredoc` ähnlich wie in den vorherigen Beispielen festlegen. Dadurch werden Probleme mit der teilweisen Konfiguration vermieden, die beim mehrfachen Bearbeiten einer Datei auftreten können. Weitere Informationen zur Konfiguration des ECS-Agenten finden Sie unter [Amazon ECS Container Agent](https://github.com/aws/amazon-ecs-agent/blob/master/README.md#environment-variables) unter GitHub.
   + Optional können Sie die Variable `CREDENTIALS_FETCHER_HOST` verwenden, wenn Sie die `credentials-fetcher`-Daemon-Konfiguration ändern, um den Socket an einen anderen Ort zu verschieben.

**Einrichten von Berechtigungen und Secrets**  
Führen Sie die folgenden Schritte einmal für jede Anwendung und jede Aufgabendefinition aus. Wir empfehlen Ihnen, die bewährte Methode anzuwenden, die geringste Berechtigung zu gewähren und die in der Richtlinie verwendeten Berechtigungen einzuschränken. Auf diese Weise kann jede Aufgabe nur die Secrets lesen, die sie benötigt.

1. <a name="linux-gmsa-domainless-secret"></a>

**(Optional) domainloses gMSA-Secret**

   Wenn Sie die domainlose Methode verwenden, bei der die Instance nicht mit der Domain verknüpft ist, gehen Sie wie folgt vor.

   Sie müssen die folgenden Berechtigungen als eingebundene Richtlinie zu der IAM-Rolle für die Aufgabenausführung hinzufügen. Dadurch erhält der `credentials-fetcher`-Daemon Zugriff auf das Secrets-Manager-Secret. Ersetzen Sie das Beispiel-`MySecret` durch den Amazon-Ressourcenname (ARN) Ihres Secrets in der `Resource`-Liste.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret-AbCdEf"
           }
       ]
   }
   ```

------
**Anmerkung**  
Wenn Sie Ihren eigenen KMS-Schlüssel verwenden, um Ihr Geheimnis zu verschlüsseln, müssen Sie dieser Rolle die erforderlichen Berechtigungen hinzufügen und diese Rolle der AWS KMS Schlüsselrichtlinie hinzufügen.

1. 

**Entscheiden Sie, ob Sie SSM Parameter Store oder S3 zum Speichern von CredSpec verwenden**

   Amazon ECS unterstützt die folgenden Möglichkeiten, um auf den Dateipfad im `credentialSpecs`-Feld der Aufgabendefinition zu verweisen.

   Wenn Sie die Instances mit einer einzigen Domain verbinden, verwenden Sie das Präfix `credentialspec:` am Anfang des ARN in der Zeichenfolge. Wenn Sie domainlose gMSA verwenden, verwenden Sie `credentialspecdomainless:`.

   Weitere Informationen zu CredSpecfinden Sie unter [Anmeldeinformationsspezifikationsdatei](#linux-gmsa-credentialspec).
   + <a name="linux-gmsa-credspec-s3"></a>

**Amazon S3 Bucket**

     Fügen Sie die Anmeldeinformationsspezifikation zu einem Amazon-S3-Bucket hinzu. Dann verweisen Sie auf den Amazon-Ressourcennamen (ARN) des Amazon-S3-Buckets im `credentialSpecs`-Feld der Aufgabendefinition.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Um Ihren Aufgaben den Zugriff auf den S3-Bucket zu ermöglichen, fügen Sie die folgenden Berechtigungen als eingebundene Richtlinie zur IAM-Rolle für die Aufgabenausführung von Amazon ECS hinzu.

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

****  

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

------
   + <a name="linux-gmsa-credspec-ssm"></a>

**SSM-Parameterspeicher-Parameter**

     Fügen Sie die Anmeldeinformationsspezifikation zu einem SSM-Parameter-Store-Parameter hinzu. Dann verweisen Sie auf den Amazon-Ressourcennamen (ARN) des SSM-Parameter-Store-Parameters im `credentialSpecs`-Feld der Aufgabendefinition.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:ssm:aws-region:111122223333:parameter/parameter_name"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Um Ihren Aufgaben Zugriff auf den Parameter des SSM Parameter Store zu geben, fügen Sie die folgenden Berechtigungen als eingebundene Richtlinie zur Amazon-ECS-IAM-Rolle für die Aufgabenausführung hinzu.

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Effect": "Allow",
                 "Action": [
                     "ssm:GetParameters"
                 ],
                 "Resource": "arn:aws:ssm:us-east-1:123456789012:parameter/my-parameter"
             }
         ]
     }
     ```

------

## Anmeldeinformationsspezifikationsdatei
<a name="linux-gmsa-credentialspec"></a>

Amazon ECS verwendet eine Spezifikationsdatei für Active-Directory-Anmeldeinformationen (*CredSpec*). Diese Datei enthält die gMSA-Metadaten, die verwendet werden, um den gMSA-Kontokontext an den Linux-Container weiterzuleiten. Sie erstellen CredSpec und verweisen darauf in dem `credentialSpecs`-Feld in Ihrer Aufgabendefinition. Die CredSpec-Datei enthält keine Secrets.

Im Folgenden sehen Sie ein Beispiel für eine CredSpec-Datei.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="linux-gmsa-credentialspec-create"></a>
**Erstellen einer CredSpec**  
Sie erstellen eine CredSpec indem Sie das Modul CredSpec PowerShell auf einem Windows-Computer verwenden, der mit der Domain verbunden ist. Folgen Sie den Schritten unter [Anmeldeinformationsspezifikation erstellen](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) auf der Microsoft-Learn-Website.

# Verwendung von gMSA für Linux-Container in Fargate
<a name="fargate-linux-gmsa"></a>

Amazon ECS unterstützt die Active-Directory-Authentifizierung für Linux-Container in Fargate über ein spezielles Servicekonto namens *group Managed Service Account* (gMSA).

Linux-basierte Netzwerkanwendungen wie .NET-Core-Anwendungen können Active Directory verwenden, um die Authentifizierung und Autorisierung zwischen Benutzern und Services zu verwalten. Sie können dieses Feature nutzen, indem Sie Anwendungen entwickeln, die mit Active Directory integriert sind und auf Domain-verbundenen Servern laufen. Da Linux-Container jedoch nicht mit einer Domain verbunden werden können, müssen Sie einen Linux-Container für die Ausführung mit gMSA konfigurieren.

## Überlegungen
<a name="fargate-linux-gmsa-considerations"></a>

Beachten Sie Folgendes, bevor Sie gMSA für Linux-Container in Fargate verwenden:
+ Sie müssen die Plattformversion 1.4 oder höher ausführen.
+ Möglicherweise benötigen Sie einen Windows-Computer, der mit der Domain verbunden ist, um die Voraussetzungen zu erfüllen. Beispielsweise benötigen Sie möglicherweise einen Windows-Computer, welcher mit der Domain verbunden ist, um die gMSA in Active Directory mit PowerShell zu erstellen. Die RSAT Active PowerShell Director-Tools sind nur für Windows verfügbar. Weitere Informationen finden Sie unter [Installieren der Active-Directory-Verwaltungstools](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html).
+ Sie müssen **domainless gMSA** verwenden. 

  Amazon ECS verwendet eine Spezifikationsdatei für Active-Directory-Anmeldeinformationen (CredSpec). Diese Datei enthält die gMSA-Metadaten, die verwendet werden, um den gMSA-Kontokontext an den Container weiterzuleiten. Sie generieren die CredSpec-Datei und speichern sie anschließend in einem Amazon-S3-Bucket.
+ Eine Aufgabe kann nur ein Active Directory unterstützen.

## Voraussetzungen
<a name="fargate-linux-gmsa-prerequisites"></a>

Bevor Sie das gMSA-Feature für Linux-Container mit Amazon ECS verwenden, müssen Sie folgende Schritte ausführen:
+ Sie richten eine Active-Directory-Domain mit den Ressourcen ein, auf die Ihre Container zugreifen sollen. Amazon ECS unterstützt die folgenden Einrichtungen:
  + Ein Directory Service Active Directory. Directory Service ist ein AWS verwaltetes Active Directory, das auf Amazon EC2 gehostet wird. Weitere Informationen finden Sie unter [Erste Schritte mit AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) im *AWS Directory Service Administratorhandbuch*.
  + Ein On-Premises-Active-Directory. Sie müssen sicherstellen, dass die Container-Instance von Amazon ECS Linux der Domain beitreten kann. Weitere Informationen finden Sie unter [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Sie haben ein vorhandenes gMSA-Konto im Active Directory und einen Benutzer, der berechtigt ist, auf das gMSA-Servicekonto zuzugreifen. Weitere Informationen finden Sie unter [Erstellen Sie einen Active-Directory-Benutzer für domainlose gMSA](#fargate-linux-gmsa-initial-domainless).
+ Sie haben einen Amazon-S3-Bucket. Weitere Informationen finden Sie unter [Erstellen eines Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) im *Benutzerhandbuch für Amazon S3*.

## Einrichten von gMSA-fähigen Linux-Containern unter Amazon ECS
<a name="fargate-linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Die Infrastruktur vorbereiten**  
Bei den folgenden Schritten handelt es sich um Überlegungen und Einstellungen, die einmal durchgeführt werden müssen. 
+ <a name="fargate-linux-gmsa-initial-domainless"></a>

**Erstellen Sie einen Active-Directory-Benutzer für domainlose gMSA**

  Wenn Sie domainless gMSA verwenden, ist der Container nicht mit der Domain verbunden. Andere Anwendungen, die auf dem Container ausgeführt werden, können die Anmeldeinformationen nicht für den Zugriff auf die Domain verwenden. Aufgaben, die eine andere Domain verwenden, können auf demselben Container ausgeführt werden. Sie geben den Namen eines Geheimnisses AWS Secrets Manager in der CredSpec Datei an. Das Secret muss einen Benutzernamen, ein Passwort und die Domain enthalten, bei der die Anmeldung erfolgen soll.

  Dieses Feature ähnelt dem *gMSA support for non-domain-joined container hosts*-Feature. Weitere Informationen zum Windows-Feature finden Sie unter [gMSA-Architektur und -Verbesserungen](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) auf der Microsoft-Learn-Website.

  1. Konfigurieren Sie einen Benutzer in Ihrer Active-Directory-Domain. Der Benutzer in Active Directory muss berechtigt sein, auf die gMSA-Servicekonten zuzugreifen, die Sie für die Aufgaben verwenden.

  1. Sie haben eine VPC und Subnetze, die den Active Directory-Domainnamen auflösen können. Konfigurieren Sie die VPC mit DHCP-Optionen mit dem Domain-Namen, der auf den Active-Directory-Servicenamen verweist. Weitere Informationen zur Konfiguration von DHCP-Optionen für eine VPC finden Sie unter [Mit DHCP-Optionssätzen arbeiten](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html) im *Benutzerhandbuch für Amazon Virtual Private Cloud*.

  1. Erstellen Sie ein Geheimnis in AWS Secrets Manager. 

  1. Erstellen Sie die Spezifikationsdatei mit den Anmeldeinformationen.

**Einrichten von Berechtigungen und Secrets**  
Führen Sie die folgenden Schritte einmal für jede Anwendung und jede Aufgabendefinition aus. Wir empfehlen Ihnen, die bewährte Methode anzuwenden, die geringste Berechtigung zu gewähren und die in der Richtlinie verwendeten Berechtigungen einzuschränken. Auf diese Weise kann jede Aufgabe nur die Secrets lesen, die sie benötigt.

1. Erstellen Sie einen Benutzer in Ihrer Active-Directory-Domain. Der Benutzer in Active Directory muss berechtigt sein, auf die gMSA-Servicekonten zuzugreifen, die Sie für die Aufgaben verwenden.

1. Nachdem Sie den Active Directory-Benutzer eingerichtet haben, erstellen Sie ein Geheimnis in AWS Secrets Manager. Weitere Informationen finden Sie unter [Ein AWS Secrets Manager -Secret erstellen](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

1. Geben Sie den Benutzernamen, das Passwort und die Domain des Benutzers in JSON-Schlüssel-Wert-Paare mit den Bezeichnungen `username`, `password` bzw. `domainName`, ein.

   ```
   {"username":"username","password":"passw0rd", "domainName":"example.com"}
   ```

1. <a name="fargate-linux-gmsa-domainless-secret"></a>Sie müssen die folgenden Berechtigungen als eingebundene Richtlinie zu der IAM-Rolle für die Aufgabenausführung hinzufügen. Dadurch erhält der `credentials-fetcher`-Daemon Zugriff auf das Secrets-Manager-Secret. Ersetzen Sie das Beispiel-`MySecret` durch den Amazon-Ressourcenname (ARN) Ihres Secrets in der `Resource`-Liste.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": [
               "arn:aws:secretsmanager:us-east-1:111122223333:secret:MySecret"
               ]
           }
       ]
   }
   ```

------
**Anmerkung**  
Wenn Sie Ihren eigenen KMS-Schlüssel verwenden, um Ihr Geheimnis zu verschlüsseln, müssen Sie dieser Rolle die erforderlichen Berechtigungen hinzufügen und diese Rolle der AWS KMS Schlüsselrichtlinie hinzufügen.

1. <a name="linux-gmsa-credspec-ssm"></a>Fügen Sie die Anmeldeinformationsspezifikation zu einem Amazon-S3-Bucket hinzu. Dann verweisen Sie auf den Amazon-Ressourcennamen (ARN) des Amazon-S3-Buckets im `credentialSpecs`-Feld der Aufgabendefinition.

   ```
   {
       "family": "",
       "executionRoleArn": "",
       "containerDefinitions": [
           {
               "name": "",
               ...
               "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
               ],
               ...
           }
       ],
       ...
   }
   ```

   Um Ihren Aufgaben den Zugriff auf den S3-Bucket zu ermöglichen, fügen Sie die folgenden Berechtigungen als eingebundene Richtlinie zur IAM-Rolle für die Aufgabenausführung von Amazon ECS hinzu.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "VisualEditor",
               "Effect": "Allow",
               "Action": [
               "s3:GetObjectVersion",
               "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::{bucket_name}",
                   "arn:aws:s3:::{bucket_name}/{object}"
               ]
           }
       ]
   }
   ```

------

## Anmeldeinformationsspezifikationsdatei
<a name="fargate-linux-gmsa-credentialspec"></a>

Amazon ECS verwendet eine Spezifikationsdatei für Active-Directory-Anmeldeinformationen (*CredSpec*). Diese Datei enthält die gMSA-Metadaten, die verwendet werden, um den gMSA-Kontokontext an den Linux-Container weiterzuleiten. Sie erstellen CredSpec und verweisen darauf in dem `credentialSpecs`-Feld in Ihrer Aufgabendefinition. Die CredSpec-Datei enthält keine Secrets.

Im Folgenden sehen Sie ein Beispiel für eine CredSpec-Datei.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="fargate-linux-gmsa-credentialspec-create"></a>
**Erstellen und Hochladen eines CredSpec an Amazon S3**  
Sie erstellen eine CredSpec indem Sie das Modul CredSpec PowerShell auf einem Windows-Computer verwenden, der mit der Domain verbunden ist. Folgen Sie den Schritten unter [Anmeldeinformationsspezifikation erstellen](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) auf der Microsoft-Learn-Website.

Nachdem Sie die Anmeldeinformations-Spezifikationsdatei erstellt haben, laden Sie sie in einen Amazon-S3-Bucket hoch. Kopieren Sie die CredSpec-Datei auf den Computer oder die Umgebung, in der Sie AWS CLI -Befehle ausführen.

Führen Sie den folgenden AWS CLI Befehl aus, CredSpec um das auf Amazon S3 hochzuladen. Ersetzen Sie `amzn-s3-demo-bucket` durch den Namen Ihres Amazon-S3-Buckets. Sie können die Datei als Objekt in einem beliebigen Bucket und an einem beliebigen Ort speichern, müssen jedoch in der Richtlinie, die Sie der Aufgabenausführungsrolle zuordnen, den Zugriff auf diesen Bucket und diesen Speicherort gewähren.

Verwenden PowerShell Sie für den folgenden Befehl:

```
$ Write-S3Object -BucketName "amzn-s3-demo-bucket" -Key "ecs-domainless-gmsa-credspec" -File "gmsa-cred-spec.json"
```

Der folgende AWS CLI Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. 

```
$ aws s3 cp gmsa-cred-spec.json \
s3://amzn-s3-demo-bucket/ecs-domainless-gmsa-credspec
```

# Verwenden von Amazon ECS-Windows-Containern mit domainless unter gMSA Verwendung von AWS CLI
<a name="tutorial-gmsa-windows"></a>

Die folgende Anleitung zeigt, wie Sie eine Amazon-ECS-Aufgabe erstellen, die einen Windows-Container ausführt, der über Anmeldeinformationen für den Zugriff auf Active Directory mit AWS CLI verfügt. Durch die Verwendung von domainlosen gMSA ist die Container-Instance nicht mit der Domain verbunden, andere Anwendungen auf der Instance können die Anmeldeinformationen nicht verwenden, um auf die Domain zuzugreifen, und Aufgaben, die verschiedenen Domains angehören, können auf derselben Instance ausgeführt werden.

**Topics**
+ [Voraussetzungen](#tutorial-gmsa-windows-prerequisites)
+ [Schritt 1: Das gMSA-Konto in den Active Directory-Domain-Services (AD DS) erstellen und konfigurieren](#tutorial-gmsa-windows-step1)
+ [Schritt 2: Die Anmeldeinformationen in Secrets Manager hochladen](#tutorial-gmsa-windows-step2)
+ [Schritt 3: Ihre CredSpec-JSON-Datei so ändern, dass sie Informationen von domainlosen gMSA enthält](#tutorial-gmsa-windows-step3)
+ [Schritt 4: CredSpec auf Amazon S3 hochladen](#tutorial-gmsa-windows-step4)
+ [Schritt 5 (Optional): Ein Amazon-ECS-Cluster erstellen](#tutorial-gmsa-windows-step5)
+ [Schritt 6: Eine IAM-Rolle für Container-Instances erstellen](#tutorial-gmsa-windows-step6)
+ [Schritt 7: Eine benutzerdefinierte Aufgaben-Ausführungsrolle erstellen](#tutorial-gmsa-windows-step7)
+ [Schritt 8: Eine Aufgabenrolle für Amazon ECS Exec erstellen](#tutorial-gmsa-windows-step8)
+ [Schritt 9: Eine Aufgabendefinition erstellen, die domainlose gMSA verwendet](#tutorial-gmsa-windows-step9)
+ [Schritt 10: Eine Windows-Container-Instance im Cluster registrieren](#tutorial-gmsa-windows-step10)
+ [Schritt 11: Container-Instance überprüfen](#tutorial-gmsa-windows-step11)
+ [Schritt 12: Eine Windows-Aufgabe ausführen](#tutorial-gmsa-windows-step12)
+ [Schritt 13: Sicherstellen, dass der Container über gMSA-Anmeldeinformationen verfügt](#tutorial-gmsa-windows-step13)
+ [Schritt 14: Bereinigen](#tutorial-gmsa-windows-step14)
+ [Debuggen von Amazon ECS domainlosen gMSA für Windows-Container](#tutorial-gmsa-windows-debugging)

## Voraussetzungen
<a name="tutorial-gmsa-windows-prerequisites"></a>

In diesem Tutorial wird davon ausgegangen, dass die folgenden Voraussetzungen erfüllt wurden:
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
+  Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen zur Installation oder Aktualisierung von finden Sie AWS CLI unter [Installation von AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Anmerkung**  
Sie können Dual-Stack-Service-Endpunkte verwenden, um mit Amazon ECS über die AWS CLI SDKs, und die Amazon ECS-API sowohl über als auch IPv4 zu interagieren. IPv6 Weitere Informationen finden Sie unter [Verwenden von Dual-Stack-Endpunkten in Amazon ECS](dual-stack-endpoint.md).
+ Sie richten eine Active-Directory-Domain mit den Ressourcen ein, auf die Ihre Container zugreifen sollen. Amazon ECS unterstützt die folgenden Einrichtungen:
  + Ein Directory Service Active Directory. Directory Service ist ein AWS verwaltetes Active Directory, das auf Amazon EC2 gehostet wird. Weitere Informationen finden Sie unter [Erste Schritte mit AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) im *AWS Directory Service Administratorhandbuch*.
  + Ein On-Premises-Active-Directory. Sie müssen sicherstellen, dass die Container-Instance von Amazon ECS Linux der Domain beitreten kann. Weitere Informationen finden Sie unter [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Sie haben eine VPC und Subnetze, die den Active Directory-Domainnamen auflösen können.
+ Sie haben zwischen **domainlose gMSA** und **Hinzufügen jeder Instance zu einer einzelnen Domain** gewählt. Durch die Verwendung von domainlosen gMSA ist die Container-Instance nicht mit der Domain verbunden, andere Anwendungen auf der Instance können die Anmeldeinformationen nicht verwenden, um auf die Domain zuzugreifen, und Aufgaben, die verschiedenen Domains angehören, können auf derselben Instance ausgeführt werden.

  Wählen Sie dann den Datenspeicher für CredSpec und optional für die Active-Directory-Benutzeranmeldeinformationen für domainlose gMSA.

  Amazon ECS verwendet eine Spezifikationsdatei für Active-Directory-Anmeldeinformationen (CredSpec). Diese Datei enthält die gMSA-Metadaten, die verwendet werden, um den gMSA-Kontokontext an den Container weiterzuleiten. Sie generieren die CredSpec-Datei und speichern sie dann in einer der CredSpec-Speicheroptionen in der folgenden Tabelle, die für das Betriebssystem der Container-Instances spezifisch sind. Um die domainlose Methode zu verwenden, kann ein optionaler Abschnitt in der CredSpec-Datei Anmeldeinformationen in einer der *domainless user credentials*-Speicheroptionen in der folgenden Tabelle angeben, die für das Betriebssystem der Container-Instances spezifisch sind.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonECS/latest/developerguide/tutorial-gmsa-windows.html)
+ (Optional) AWS CloudShell ist ein Tool, das Kunden eine Befehlszeile bietet, ohne ihre eigene EC2-Instance erstellen zu müssen. Weitere Informationen finden Sie unter [Was ist? AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) im *AWS CloudShell Benutzerhandbuch*.

## Schritt 1: Das gMSA-Konto in den Active Directory-Domain-Services (AD DS) erstellen und konfigurieren
<a name="tutorial-gmsa-windows-step1"></a>

Erstellen und konfigurieren Sie ein gMSA-Konto in der Active Directory-Domain.

**Anmerkung**  
In diesem Schritt werden zwei separate Konten erstellt: ein group Managed Service Account (gMSA), das die Identität für Ihre Container bereitstellt, und ein reguläres Benutzerkonto, das für die Domain-Authentifizierung verwendet wird. Diese Konten dienen unterschiedlichen Zwecken und sollten unterschiedliche Namen haben.

1. 

**Ein Stammschlüssel für den Schlüsselverteilungs-Service generieren**
**Anmerkung**  
Wenn Sie verwenden Directory Service, können Sie diesen Schritt überspringen.

   Der KDS-Stammschlüssel und die gMSA-Berechtigungen werden mit Ihrem AWS Managed Microsoft AD konfiguriert.

   Wenn Sie in Ihrer Domain noch kein gMSA-Servicekonto erstellt haben, müssen Sie zunächst einen Stammschlüssel für den Key Distribution Service (KDS, Schlüsselverteilung) generieren. KDS ist für die Erstellung, Rotation und Weitergabe des gMSA-Passworts an autorisierte Hosts verantwortlich. Wenn `ccg.exe` gMSA-Anmeldeinformationen abrufen muss, wendet es sich an KDS, um das aktuelle Passwort abzurufen.

   Um zu überprüfen, ob der KDS-Stammschlüssel bereits erstellt wurde, führen Sie mithilfe des Moduls das folgende PowerShell Cmdlet mit Domänenadministratorrechten auf einem Domänencontroller aus. `ActiveDirectory` PowerShell Weitere Informationen zum Modul finden Sie unter [ActiveDirectory Modul](https://learn.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2022-ps) auf der Microsoft Learn-Website.

   ```
   PS C:\> Get-KdsRootKey
   ```

   Wenn der Befehl eine Schlüssel-ID zurückgibt, können Sie den Rest dieses Schritts überspringen. Erstellen Sie andernfalls den KDS-Stammschlüssel, indem Sie den folgenden Befehl ausführen:

   ```
   PS C:\> Add-KdsRootKey -EffectiveImmediately
   ```

   Obwohl das Argument `EffectiveImmediately` des Befehls impliziert, dass der Schlüssel sofort gültig ist, müssen Sie 10 Stunden warten, bis der KDS-Stammschlüssel repliziert und auf allen Domain-Controllern verwendet werden kann.

1. 

**Das gMSA-Konto erstellen**

   Um das gMSA Konto zu erstellen und das Abrufen des gMSA Kennworts `ccg.exe` zu ermöglichen, führen Sie die folgenden PowerShell Befehle von einem Windows-Server oder -Client aus, der Zugriff auf die Domäne hat. Ersetzen Sie `ExampleAccount` durch den Namen, den Sie für Ihr gMSA-Konto verwenden möchten, und ersetzen Sie `example-domain` durch Ihren Active-Directory-Domain-Namen (verwenden Sie beispielsweise `contoso`, falls Ihre Domain `contoso.com` lautet).

   1. 

      ```
      PS C:\> Install-WindowsFeature RSAT-AD-PowerShell
      ```

   1. 

      ```
      PS C:\> New-ADGroup -Name "ExampleAccount Authorized Hosts" -SamAccountName "ExampleAccountHosts" -GroupScope DomainLocal
      ```

   1. 

      ```
      PS C:\> New-ADServiceAccount -Name "ExampleAccount" -DnsHostName "example-domain" -ServicePrincipalNames "host/ExampleAccount", "host/example-domain" -PrincipalsAllowedToRetrieveManagedPassword "ExampleAccountHosts"
      ```

   1. Erstellen Sie einen Benutzer mit einem permanenten Passwort, das nicht abläuft. Diese Anmeldeinformationen werden in jeder Aufgabe gespeichert AWS Secrets Manager und von ihnen verwendet, um der Domäne beizutreten. Dieses Benutzerkonto ist separat von dem oben erstellten gMSA-Konto. Ersetzen Sie `ExampleServiceUser` durch den Namen, den Sie für dieses Service-Benutzerkonto verwenden möchten.

      ```
      PS C:\> New-ADUser -Name "ExampleServiceUser" -AccountPassword (ConvertTo-SecureString -AsPlainText "Test123" -Force) -Enabled 1 -PasswordNeverExpires 1
      ```

   1. 

      ```
      PS C:\> Add-ADGroupMember -Identity "ExampleAccountHosts" -Members "ExampleServiceUser"
      ```

   1. Installieren Sie das PowerShell Modul zum Erstellen von CredSpec Objekten in Active Directory und geben Sie das CredSpec JSON aus.

      ```
      PS C:\> Install-PackageProvider -Name NuGet -Force
      ```

      ```
      PS C:\> Install-Module CredentialSpec
      ```

   1. 

      ```
      PS C:\> New-CredentialSpec -AccountName ExampleAccount
      ```

1. Kopieren Sie die JSON-Ausgabe des vorherigen Befehls in eine Datei mit dem Namen `gmsa-cred-spec.json`. Das ist die CredSpec-Datei. Sie wird in Schritt 3, [Schritt 3: Ihre CredSpec-JSON-Datei so ändern, dass sie Informationen von domainlosen gMSA enthält](#tutorial-gmsa-windows-step3), verwendet.

## Schritt 2: Die Anmeldeinformationen in Secrets Manager hochladen
<a name="tutorial-gmsa-windows-step2"></a>

Kopieren Sie die Active-Directory-Anmeldeinformationen in ein sicheres Speichersystem für Anmeldeinformationen, sodass sie bei jeder Aufgabe abgerufen werden. Dies ist die domainlose gMSA Methode. Durch die Verwendung von domainlosen gMSA ist die Container-Instance nicht mit der Domain verbunden, andere Anwendungen auf der Instance können die Anmeldeinformationen nicht verwenden, um auf die Domain zuzugreifen, und Aufgaben, die verschiedenen Domains angehören, können auf derselben Instance ausgeführt werden.

In diesem Schritt wird der verwendet AWS CLI. Sie können diese Befehle in AWS CloudShell in der Standard-Shell ausführen, und zwar `bash`.
+ Führen Sie den folgenden AWS CLI Befehl aus und ersetzen Sie den Benutzernamen, das Passwort und den Domainnamen entsprechend Ihrer Umgebung. Verwenden Sie den Namen des Service-Benutzerkontos (nicht den gMSA-Kontonamen) als Benutzernamen. Bewahren Sie den ARN des Secrets auf, um es im nächsten Schritt, [Schritt 3: Ihre CredSpec-JSON-Datei so ändern, dass sie Informationen von domainlosen gMSA enthält](#tutorial-gmsa-windows-step3), zu verwenden

  Der folgende Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. Dieser Befehl ist nicht kompatibel mit PowerShell. Sie müssen den Befehl ändern, um ihn mit verwenden zu können PowerShell.

  ```
  $ aws secretsmanager create-secret \
  --name gmsa-plugin-input \
  --description "Amazon ECS - gMSA Portable Identity." \
  --secret-string "{\"username\":\"ExampleServiceUser\",\"password\":\"Test123\",\"domainName\":\"contoso.com\"}"
  ```

## Schritt 3: Ihre CredSpec-JSON-Datei so ändern, dass sie Informationen von domainlosen gMSA enthält
<a name="tutorial-gmsa-windows-step3"></a>

Bevor Sie das CredSpec in eine der Speicheroptionen hochladen, fügen Sie der CredSpec Informationen mit dem ARN des Secrets im Secrets Manager aus dem vorherigen Schritt hinzu. Weitere Informationen finden Sie unter [Konfiguration zusätzlicher Anmeldeinformationen für den Anwendungsfall non-domain-joined Container-Hosts](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) auf der Microsoft Learn-Website.

1. Fügen Sie der CredSpec-Datei in der `ActiveDirectoryConfig` die folgende Information hinzu. Ersetzen Sie den ARN durch das Secret im Secrets Manager aus dem vorherigen Schritt.

   Beachten Sie, dass der `PluginGUID`-Wert mit der GUID im folgenden Beispielausschnitt übereinstimmen muss und erforderlich ist.

   ```
   "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   Sie können auch ein Secret im SSM Parameter Store verwenden, indem Sie den ARN in diesem Format verwenden: `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`.

1. Nachdem Sie die CredSpec-Datei geändert haben, sollte sie wie im folgenden Beispiel aussehen:

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "ExampleAccount",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "example-domain",
       "DnsName": "example-domain",
       "NetBiosName": "example-domain"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         },
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

## Schritt 4: CredSpec auf Amazon S3 hochladen
<a name="tutorial-gmsa-windows-step4"></a>



In diesem Schritt wird der verwendet. AWS CLI Sie können diese Befehle in AWS CloudShell in der Standard-Shell ausführen, und zwar `bash`.

1. Kopieren Sie die CredSpec-Datei auf den Computer oder die Umgebung, in der Sie AWS CLI -Befehle ausführen.

1. Führen Sie den folgenden AWS CLI Befehl aus, CredSpec um das auf Amazon S3 hochzuladen. Ersetzen Sie `MyBucket` durch den Namen Ihres Amazon-S3-Buckets. Sie können die Datei als Objekt in einem beliebigen Bucket und an einem beliebigen Ort speichern, müssen jedoch in der Richtlinie, die Sie der Aufgabenausführungsrolle zuordnen, den Zugriff auf diesen Bucket und diesen Speicherort gewähren.

   Der folgende Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. Dieser Befehl ist nicht kompatibel mit PowerShell. Sie müssen den Befehl ändern, um ihn mit verwenden zu können PowerShell.

   ```
   $ aws s3 cp gmsa-cred-spec.json \
   s3://MyBucket/ecs-domainless-gmsa-credspec
   ```

## Schritt 5 (Optional): Ein Amazon-ECS-Cluster erstellen
<a name="tutorial-gmsa-windows-step5"></a>

Standardmäßig hat Ihr Konto einen Amazon-ECS-Cluster mit dem Namen `default`. Dieser Cluster wird standardmäßig in AWS CLI SDKs, und verwendet CloudFormation. Sie können zusätzliche Cluster verwenden, um Aufgaben und Infrastruktur zu gruppieren und zu organisieren und bestimmten Konfigurationen Standardwerte zuzuweisen.

Sie können einen Cluster aus dem AWS-Managementkonsole, AWS CLI SDKs, oder erstellen CloudFormation. Die Einstellungen und die Konfiguration im Cluster wirken sich nicht auf gMSA aus.

In diesem Schritt wird der verwendet AWS CLI. Sie können diese Befehle in AWS CloudShell in der Standard-Shell ausführen, und zwar `bash`.

```
$ aws ecs create-cluster --cluster-name windows-domainless-gmsa-cluster
```

**Wichtig**  
Wenn Sie einen eigenen Cluster erstellen möchten, müssen Sie für jeden Befehl, den Sie mit diesem Cluster verwenden möchten, `--cluster clusterName` angeben.

## Schritt 6: Eine IAM-Rolle für Container-Instances erstellen
<a name="tutorial-gmsa-windows-step6"></a>

Eine *Container-Instance* ist ein Host-Computer zum Ausführen von Containern in ECS-Aufgaben, beispielsweise Amazon-EC2-Instances. Jede Container-Instance wird bei einem Amazon ECS-Cluster registriert. Bevor Sie Amazon-EC2-Instances starten und sie in einem Cluster registrieren, müssen Sie eine IAM-Rolle erstellen, die ihre Container-Instances verwenden können.

Wie Sie die Rolle der Container-Instance erstellen, erfahren Sie unter [IAM-Rolle für Amazon-ECS-Container-Instance](instance_IAM_role.md). Die Standard-`ecsInstanceRole` verfügt über ausreichende Berechtigungen, um dieses Tutorial abzuschließen.

## Schritt 7: Eine benutzerdefinierte Aufgaben-Ausführungsrolle erstellen
<a name="tutorial-gmsa-windows-step7"></a>

Amazon ECS kann anstelle der Container-Instance-Rolle eine andere IAM-Rolle für die Berechtigungen verwenden, die zum Starten der einzelnen Aufgaben erforderlich sind. Diese Rolle ist die *Aufgabenausführungsrolle*. Wir empfehlen, eine Aufgabenausführungsrolle nur mit den Berechtigungen zu erstellen, die ECS zur Ausführung der Aufgabe benötigt, auch bekannt als *geringste Berechtigung*. Weitere Informationen zum Prinzip der geringsten Rechte finden Sie unter [SEC03- BP02 Gewähren Sie den geringsten Zugriff](https://docs.aws.amazon.com/wellarchitected/latest/framework/sec_permissions_least_privileges.html) im *AWS Well-Architected Framework*.

1. Um eine Aufgabenausführungsrolle zu erstellen, siehe [Erstellen der -Aufgabenausführungsrolle](task_execution_IAM_role.md#create-task-execution-role). Die Standardberechtigungen ermöglichen es der Container-Instance, Container-Images aus Amazon Elastic Container Registry `stdout` und `stderr` aus Ihren Anwendungen abzurufen, um sie in Amazon CloudWatch Logs zu protokollieren.

   Da die Rolle für dieses Tutorial benutzerdefinierte Berechtigungen benötigt, können Sie der Rolle einen anderen Namen als `ecsTaskExecutionRole` geben. In diesem Tutorial wird `ecsTaskExecutionRole` in weiteren Schritten verwendet.

1. Fügen Sie die folgenden Berechtigungen hinzu, indem Sie eine benutzerdefinierte Richtlinie erstellen, entweder eine Inline-Richtlinie, die nur für diese Rolle existiert, oder eine Richtlinie, die Sie wiederverwenden können. Ersetzen Sie den ARN für die `Resource` in der ersten Anweisung durch den Amazon-S3-Bucket und den Speicherort und die zweite `Resource` durch den ARN des Secrets im Secrets Manager.

   Wenn Sie das Secret im Secrets Manager mit einem benutzerdefinierten Schlüssel verschlüsseln, müssen Sie auch `kms:Decrypt` für den Schlüssel zulassen.

   Wenn Sie SSM Parameter Store anstelle von Secrets Manager verwenden, müssen Sie `ssm:GetParameter` für den Parameter anstelle von `secretsmanager:GetSecretValue` zulassen.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject"
               ],
               "Resource": "arn:aws:s3:::MyBucket/ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:gmsa-plugin-AbCdEf"
           }
       ]
   }
   ```

------

## Schritt 8: Eine Aufgabenrolle für Amazon ECS Exec erstellen
<a name="tutorial-gmsa-windows-step8"></a>

In diesem Tutorial wird Amazon ECS Exec verwendet, um die Funktionalität zu überprüfen, indem ein Befehl innerhalb einer laufenden Aufgabe ausgeführt wird. Um ECS Exec verwenden zu können, muss der Service oder die Aufgabe ECS Exec aktivieren und die Aufgabenrolle (aber nicht die Rolle zur Aufgabenausführung) muss über `ssmmessages`-Berechtigungen verfügen. Informationen zur erforderlichen IAM-Richtlinie finden Sie unter [ECS-Exec-Berechtigungen](task-iam-roles.md#ecs-exec-required-iam-permissions).

In diesem Schritt wird der verwendet AWS CLI. Sie können diese Befehle in AWS CloudShell in der Standard-Shell ausführen, und zwar `bash`.

Gehen Sie folgendermaßen vor AWS CLI, um eine Aufgabenrolle mithilfe von zu erstellen.

1. Erstellen Sie eine Datei mit dem Namen `ecs-tasks-trust-policy.json` und den folgenden Inhalten:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": "ecs-tasks.amazonaws.com"
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

1. Erstellen Sie eine IAM-Rolle. Sie können den Namen `ecs-exec-demo-task-role` ersetzen, aber behalten Sie den Namen für die folgenden Schritte bei.

   Der folgende Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. Dieser Befehl ist nicht kompatibel mit PowerShell. Sie müssen den Befehl ändern, um ihn mit verwenden zu können PowerShell.

   ```
   $ aws iam create-role --role-name ecs-exec-demo-task-role \
   --assume-role-policy-document file://ecs-tasks-trust-policy.json
   ```

   Sie können die Datei `ecs-tasks-trust-policy.json` löschen.

1. Erstellen Sie eine Datei mit dem Namen `ecs-exec-demo-task-role-policy.json` und den folgenden Inhalten:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ssmmessages:CreateControlChannel",
                   "ssmmessages:CreateDataChannel",
                   "ssmmessages:OpenControlChannel",
                   "ssmmessages:OpenDataChannel"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Erstellen Sie eine IAM-Richtlinie und verknüpfen Sie sie mit der Rolle aus dem vorherigen Schritt.

   Der folgende Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. Dieser Befehl ist nicht kompatibel mit PowerShell. Sie müssen den Befehl ändern, um ihn mit verwenden zu können PowerShell.

   ```
   $ aws iam put-role-policy \
       --role-name ecs-exec-demo-task-role \
       --policy-name ecs-exec-demo-task-role-policy \
       --policy-document file://ecs-exec-demo-task-role-policy.json
   ```

   Sie können die Datei `ecs-exec-demo-task-role-policy.json` löschen.

## Schritt 9: Eine Aufgabendefinition erstellen, die domainlose gMSA verwendet
<a name="tutorial-gmsa-windows-step9"></a>



In diesem Schritt wird der verwendet AWS CLI. Sie können diese Befehle in AWS CloudShell in der Standard-Shell ausführen, und zwar `bash`.

1. Erstellen Sie eine Datei mit dem Namen `windows-gmsa-domainless-task-def.json` und den folgenden Inhalten:

   ```
   {
     "family": "windows-gmsa-domainless-task",
     "containerDefinitions": [
       {
         "name": "windows_sample_app",
         "image": "mcr.microsoft.com/windows/servercore/iis",
         "cpu": 1024,
         "memory": 1024,
         "essential": true,
         "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
         ],
         "entryPoint": [
           "powershell",
           "-Command"
         ],
         "command": [
           "New-Item -Path C:\\inetpub\\wwwroot\\index.html -ItemType file -Value '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p>' -Force ; C:\\ServiceMonitor.exe w3svc"
         ],
         "portMappings": [
           {
             "protocol": "tcp",
             "containerPort": 80,
             "hostPort": 8080
           }
         ]
       }
     ],
     "taskRoleArn": "arn:aws:iam::111122223333:role/ecs-exec-demo-task-role",
     "executionRoleArn": "arn:aws:iam::111122223333:role/ecsTaskExecutionRole"
   }
   ```

1. Registrieren Sie die Aufgabendefinition, indem Sie den folgenden Befehl ausführen:

   Der folgende Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. Dieser Befehl ist nicht kompatibel mit PowerShell. Sie müssen den Befehl ändern, um ihn mit verwenden zu können PowerShell.

   ```
   $ aws ecs register-task-definition \
   --cli-input-json file://windows-gmsa-domainless-task-def.json
   ```

## Schritt 10: Eine Windows-Container-Instance im Cluster registrieren
<a name="tutorial-gmsa-windows-step10"></a>

Starten Sie eine Amazon-EC2-Windows-Instance und führen Sie den ECS-Container-Agenten aus, um sie als Container-Instance im Cluster zu registrieren. ECS führt Aufgaben auf den Container-Instances aus, die in dem Cluster registriert sind, in dem die Aufgaben gestartet werden.

1. Informationen zum Starten einer Amazon EC2 EC2-Windows-Instance, die für Amazon ECS in konfiguriert ist AWS-Managementkonsole, finden Sie unter[Starten einer Amazon ECS Windows-Container-Instance](launch_window-container_instance.md). Halten Sie beim Schritt für *Benutzerdaten* an.

1. Für gMSA müssen die Benutzerdaten die Umgebungsvariable `ECS_GMSA_SUPPORTED` festlegen, bevor der ECS-Container-Agent gestartet wird.

   Für ECS Exec muss der Agent mit dem Argument `-EnableTaskIAMRole` beginnen.

   Um die Instance-IAM-Rolle zu sichern, indem verhindert wird, dass Aufgaben den EC2-IMDS-Webservice zum Abrufen der Rollenanmeldedaten erreichen, fügen Sie das Argument `-AwsvpcBlockIMDS` hinzu. Dies gilt nur für Aufgaben, die den `awsvpc`-Netzwerkmodus verwenden.

   ```
   <powershell>
   [Environment]::SetEnvironmentVariable("ECS_GMSA_SUPPORTED", $TRUE, "Machine")
   Import-Module ECSTools
   Initialize-ECSAgent -Cluster windows-domainless-gmsa-cluster -EnableTaskIAMRole -AwsvpcBlockIMDS
   </powershell>
   ```

1. Überprüfen Sie Ihre Instance-Konfiguration im Bereich **Summary** (Übersicht). Wenn alles in Ordnung ist, klicken Sie auf **Launch instance** (Instance starten).

## Schritt 11: Container-Instance überprüfen
<a name="tutorial-gmsa-windows-step11"></a>

Mithilfe der AWS-Managementkonsole können Sie überprüfen, ob es im Cluster eine Container-Instance gibt. gMSA benötigt jedoch zusätzliche Features, die als *Attribute* angegeben sind. Diese Attribute sind in der nicht sichtbar AWS-Managementkonsole, daher verwendet dieses Tutorial die AWS CLI.

In diesem Schritt wird der verwendet AWS CLI. Sie können diese Befehle in AWS CloudShell in der Standard-Shell ausführen, und zwar `bash`.

1. Die Container-Instances im Cluster auflisten. Container-Instances haben eine ID, die sich von der ID der EC2-Instance unterscheidet.

   ```
   $ aws ecs list-container-instances
   ```

   Ausgabe:

   ```
   {
       "containerInstanceArns": [
           "arn:aws:ecs:aws-region:111122223333:container-instance/default/MyContainerInstanceID"
       ]
   }
   ```

   `526bd5d0ced448a788768334e79010fd` ist beispielsweise eine gültige Container-Instance-ID.

1. Verwenden Sie die Container-Instance-ID aus dem vorherigen Schritt, um die Details für die Container-Instance abzurufen. Ersetzen Sie `MyContainerInstanceID` durch die ID.

   Der folgende Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. Dieser Befehl ist nicht kompatibel mit PowerShell. Sie müssen den Befehl ändern, um ihn mit verwenden zu können PowerShell.

   ```
   $ aws ecs describe-container-instances \
        ----container-instances MyContainerInstanceID
   ```

   Beachten Sie, dass die Ausgabe sehr lang ist.

1. Stellen Sie sicher, dass die `attributes`-Liste ein Objekt mit dem Schlüssel namens `name` und einem Wert `ecs.capability.gmsa-domainless` enthält. Es folgt ein Beispiel für das Objekt.

   Ausgabe:

   ```
   {
       "name": "ecs.capability.gmsa-domainless"
   }
   ```

## Schritt 12: Eine Windows-Aufgabe ausführen
<a name="tutorial-gmsa-windows-step12"></a>

Führen Sie eine Amazon-ECS-Aufgabe aus. Wenn es im Cluster nur 1 Container-Instance gibt, können Sie `run-task` verwenden. Wenn es viele verschiedene Container-Instances gibt, kann es einfacher sein, `start-task` zu verwenden und die ID der Container-Instance anzugeben, auf der die Aufgabe ausgeführt werden soll, als der Aufgabendefinition Einschränkungen für die Platzierung hinzuzufügen, um zu steuern, auf welchem Typ von Container-Instance die Aufgabe ausgeführt werden soll.

In diesem Schritt wird der verwendet AWS CLI. Sie können diese Befehle in AWS CloudShell in der Standard-Shell ausführen, und zwar `bash`.

1. 

   Der folgende Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. Dieser Befehl ist nicht kompatibel mit PowerShell. Sie müssen den Befehl ändern, um ihn mit verwenden zu können PowerShell.

   ```
   aws ecs run-task --task-definition windows-gmsa-domainless-task \
       --enable-execute-command --cluster windows-domainless-gmsa-cluster
   ```

   Notieren Sie sich die Aufgaben-ID, die von dem Befehl zurückgegeben wird.

1. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Aufgabe gestartet wurde. Dieser Befehl wartet und gibt den Shell-Prompt erst zurück, wenn die Aufgabe startet. Ersetzen Sie `MyTaskID` mit der Aufgaben-ID aus dem vorherigen Schritt.

   ```
   $ aws ecs wait tasks-running --task MyTaskID
   ```

## Schritt 13: Sicherstellen, dass der Container über gMSA-Anmeldeinformationen verfügt
<a name="tutorial-gmsa-windows-step13"></a>

Stellen Sie sicher, dass der Container in der Aufgabe über ein Kerberos-Token verfügt. gMSA 

In diesem Schritt wird der verwendet AWS CLI. Sie können diese Befehle in AWS CloudShell in der Standard-Shell ausführen, und zwar `bash`.

1. 

   Der folgende Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. Dieser Befehl ist nicht kompatibel mit PowerShell. Sie müssen den Befehl ändern, um ihn mit verwenden zu können PowerShell.

   ```
   $ aws ecs execute-command \
   --task MyTaskID \
   --container windows_sample_app \
   --interactive \
   --command powershell.exe
   ```

   Die Ausgabe erfolgt in einer PowerShell Eingabeaufforderung.

1. Führen Sie den folgenden Befehl im PowerShell Terminal im Container aus.

   ```
   PS C:\> klist get ExampleAccount$
   ```

   Beachten Sie in der Ausgabe, dass der `Principal` der ist, den Sie zuvor erstellt haben.

## Schritt 14: Bereinigen
<a name="tutorial-gmsa-windows-step14"></a>

Wenn Sie mit diesem Tutorial fertig sind, sollten Sie die zugehörigen Ressourcen bereinigen, um zu vermeiden, dass Gebühren für ungenutzte Ressourcen anfallen.

In diesem Schritt wird der verwendet AWS CLI. Sie können diese Befehle in AWS CloudShell in der Standard-Shell ausführen, und zwar `bash`.

1. Die Aufgabe anhalten. Ersetzen Sie `MyTaskID` durch die Aufgaben-ID aus Schritt 12, [Schritt 12: Eine Windows-Aufgabe ausführen](#tutorial-gmsa-windows-step12).

   ```
   $ aws ecs stop-task --task MyTaskID
   ```

1. Beenden Sie die Amazon-EC2-Instance. Danach wird die Container-Instance im Cluster nach einer Stunde automatisch gelöscht.

   Sie können die Instance über die Amazon-EC2-Konsole finden und beenden. Sie können alternativ den folgenden Befehl ausführen. Um den Befehl auszuführen, suchen Sie die EC2-Instance-ID in der Ausgabe des `aws ecs describe-container-instances`-Befehls aus Schritt 1, [Schritt 11: Container-Instance überprüfen](#tutorial-gmsa-windows-step11). i-10a64379 ist ein Beispiel für eine EC2-Instance-ID.

   ```
   $ aws ec2 terminate-instances --instance-ids MyInstanceID
   ```

1. Löschen Sie die CredSpec-Datei in Amazon S3. Ersetzen Sie `MyBucket` durch den Namen Ihres Amazon-S3-Buckets.

   ```
   $ aws s3api delete-object --bucket MyBucket --key ecs-domainless-gmsa-credspec/gmsa-cred-spec.json
   ```

1. Das Secret aus Secrets Manager löschen. Wenn Sie stattdessen SSM Parameter Store verwendet haben, löschen Sie den Parameter.

   Der folgende Befehl verwendet Backslash-Fortsetzungszeichen, die von `sh` und kompatiblen Shells verwendet werden. Dieser Befehl ist nicht kompatibel mit PowerShell. Sie müssen den Befehl ändern, um ihn mit verwenden zu können PowerShell.

   ```
   $ aws secretsmanager delete-secret --secret-id gmsa-plugin-input \
        --force-delete-without-recovery
   ```

1. Melden Sie die Aufgabendefinition ab und löschen Sie sie. Wenn Sie die Registrierung der Aufgabendefinition aufheben, markieren Sie sie als inaktiv, sodass sie nicht zum Starten neuer Aufgaben verwendet werden kann. Anschließend können Sie die Aufgabendefinition löschen.

   1. Heben Sie die Registrierung der Aufgabendefinition auf, indem Sie die Version angeben. ECS erstellt automatisch Versionen von Aufgabendefinitionen, die von 1 an nummeriert sind. Sie verweisen auf die Versionen im gleichen Format wie die Beschriftungen auf Container-Images, z. B. `:1`.

      ```
      $ aws ecs deregister-task-definition --task-definition windows-gmsa-domainless-task:1
      ```

   1. Löschen Sie die Aufgabendefinition.

      ```
      $ aws ecs delete-task-definitions --task-definition windows-gmsa-domainless-task:1
      ```

1. (Optional) Löschen Sie den ECS-Cluster, falls Sie einen Cluster erstellt haben.

   ```
   $ aws ecs delete-cluster --cluster windows-domainless-gmsa-cluster
   ```

## Debuggen von Amazon ECS domainlosen gMSA für Windows-Container
<a name="tutorial-gmsa-windows-debugging"></a>



Amazon-ECS-Aufgabenstatus  
ECS versucht, eine Aufgabe genau einmal zu starten. Jede Aufgabe, bei der ein Problem auftritt, wird angehalten und auf den Status `STOPPED` gesetzt. Es gibt zwei häufige Arten von Problemen mit Aufgaben. Erstens Aufgaben, die nicht gestartet werden konnten. Zweitens Aufgaben, bei denen die Anwendung in einem der Container gestoppt wurde. Suchen Sie im AWS-Managementkonsole Feld **Grund für den Stopp** der Aufgabe nach dem Grund, warum die Aufgabe gestoppt wurde. In der AWS CLI, beschreiben Sie die Aufgabe und sehen Sie sich den `stoppedReason` an. Die Schritte im Feld AWS-Managementkonsole und AWS CLI finden Sie unter[Aufgabe-Beendet-Fehler in Amazon ECS anzeigen](stopped-task-errors.md).

Windows-Ereignisse  
Windows-Ereignisse für gMSA in Containern werden in der `Microsoft-Windows-Containers-CCG`-Protokolldatei protokolliert und befinden sich in der Ereignisanzeige im Abschnitt Anwendungen und Services in `Logs\Microsoft\Windows\Containers-CCG\Admin`. Weitere Tipps zum Debuggen finden Sie unter [Problembehandlung bei g MSAs für Windows-Container](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/gmsa-troubleshooting#non-domain-joined-container-hosts-use-event-logs-to-identify-configuration-issues) auf der Microsoft Learn-Website.

ECS-Agent-gMSA-Plug-In  
Die Protokollierung des gMSA-Plug-ins für den ECS-Agenten auf der Windows-Container-Instance befindet sich im folgenden Verzeichnis, `C:/ProgramData/Amazon/gmsa-plugin/`. Sehen Sie in diesem Protokoll nach, ob die domainlosen Benutzeranmeldeinformationen vom Speicherort, z. B. Secrets Manager, heruntergeladen wurden und ob das Format der Anmeldeinformationen korrekt gelesen wurde.

# Erfahren Sie, wie Sie gMSAs für EC2-Windows-Containers für Amazon ECS verwenden.
<a name="windows-gmsa"></a>

Amazon ECS unterstützt die Active Directory-Authentifizierung für Windows-Container über ein spezielles Service-Konto namens *group Managed Service Account* (gMSA).

Windows-basierte Netzwerkanwendungen wie .NET-Anwendungen verwenden oft Active Directory, um die Authentifizierung und das Autorisierungsmanagement zwischen Benutzern und Services zu erleichtern. Entwickler entwerfen ihre Anwendungen häufig so, dass sie sich in Active Directory integrieren lassen und zu diesem Zweck auf der Domain angehörenden Servern ausgeführt werden. Da Windows-Container nicht mit einer Domain verbunden werden können, müssen Sie einen Windows-Container für die Ausführung mit dem gMSA konfigurieren.

Ein Windows-Container, der mit dem gMSA ausgeführt wird, ist zur Abfrage der gMSA-Anmeldeinformationen vom Active Directory-Domain-Controller und zur Bereitstellung an die Container-Instance auf die Amazon-EC2-Instance seines Hosts angewiesen. Weitere Informationen finden Sie unter [G MSAs für Windows-Container erstellen](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts).

**Anmerkung**  
Für Windows-Container in Fargate wird dieses Feature nicht unterstützt.

**Topics**
+ [Überlegungen](#windows-gmsa-considerations)
+ [Voraussetzungen](#windows-gmsa-prerequisites)
+ [Einrichten von gMSA für Windows-Container auf Amazon ECS](#windows-gmsa-setup)

## Überlegungen
<a name="windows-gmsa-considerations"></a>

Folgendes sollte bei der Verwendung von g MSAs für Windows-Container beachtet werden:
+ Wenn Sie das für Amazon-ECS-optimierte Windows Server 2016 Full AMI für Ihre Container-Instances verwenden, muss der Container-Hostname mit dem gMSA-Kontonamen übereinstimmen, der in der Anmeldeinformations-Spezifikationsdatei definiert ist. Um einen Hostnamen für einen Container anzugeben, verwenden Sie den `hostname`-Containerdefinitionsparameter. Weitere Informationen finden Sie unter [Netzwerkeinstellungen](task_definition_parameters.md#container_definition_network).
+ Sie haben zwischen **domainlose gMSA** und **Hinzufügen jeder Instance zu einer einzelnen Domain** gewählt. Durch die Verwendung von domainlosen gMSA ist die Container-Instance nicht mit der Domain verbunden, andere Anwendungen auf der Instance können die Anmeldeinformationen nicht verwenden, um auf die Domain zuzugreifen, und Aufgaben, die verschiedenen Domains angehören, können auf derselben Instance ausgeführt werden.

  Wählen Sie dann den Datenspeicher für CredSpec und optional für die Active-Directory-Benutzeranmeldeinformationen für domainlose gMSA.

  Amazon ECS verwendet eine Spezifikationsdatei für Active-Directory-Anmeldeinformationen (CredSpec). Diese Datei enthält die gMSA-Metadaten, die verwendet werden, um den gMSA-Kontokontext an den Container weiterzuleiten. Sie generieren die CredSpec-Datei und speichern sie dann in einer der CredSpec-Speicheroptionen in der folgenden Tabelle, die für das Betriebssystem der Container-Instances spezifisch sind. Um die domainlose Methode zu verwenden, kann ein optionaler Abschnitt in der CredSpec-Datei Anmeldeinformationen in einer der *domainless user credentials*-Speicheroptionen in der folgenden Tabelle angeben, die für das Betriebssystem der Container-Instances spezifisch sind.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonECS/latest/developerguide/windows-gmsa.html)

## Voraussetzungen
<a name="windows-gmsa-prerequisites"></a>

Bevor Sie das gMSA-Feature für Windows-Container mit Amazon ECS verwenden, müssen Sie folgende Schritte ausführen:
+ Sie richten eine Active-Directory-Domain mit den Ressourcen ein, auf die Ihre Container zugreifen sollen. Amazon ECS unterstützt die folgenden Einrichtungen:
  + Ein Directory Service Active Directory. Directory Service ist ein AWS verwaltetes Active Directory, das auf Amazon EC2 gehostet wird. Weitere Informationen finden Sie unter [Erste Schritte mit AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) im *AWS Directory Service Administratorhandbuch*.
  + Ein On-Premises-Active-Directory. Sie müssen sicherstellen, dass die Container-Instance von Amazon ECS Linux der Domain beitreten kann. Weitere Informationen finden Sie unter [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Sie haben ein bestehendes gMSA-Konto im Active Directory. Weitere Informationen finden Sie unter [G MSAs für Windows-Container erstellen](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts).
+ **Sie haben sich für *domainlose gMSA entschieden*, oder die Container-Instance von Amazon ECS Windows, die die Amazon-ECS-Aufgabe hostet, muss mit der Domain des Active Directory *verbunden sein* und Mitglied der Active-Directory-Sicherheitsgruppe sein, die Zugriff auf das gMSA-Konto hat.**

  Durch die Verwendung von domainlosen gMSA ist die Container-Instance nicht mit der Domain verbunden, andere Anwendungen auf der Instance können die Anmeldeinformationen nicht verwenden, um auf die Domain zuzugreifen, und Aufgaben, die verschiedenen Domains angehören, können auf derselben Instance ausgeführt werden.
+ Sie haben die erforderlichen IAM-Berechtigungen hinzugefügt. Welche Berechtigungen erforderlich sind, hängt von den Methoden ab, die Sie für die anfänglichen Anmeldeinformationen und für die Speicherung der Anmeldeinformation wählen:
  + Wenn Sie *Domainless gMSA* für anfängliche Anmeldeinformationen verwenden, AWS Secrets Manager sind IAM-Berechtigungen für für die Amazon EC2 EC2-Instance-Rolle erforderlich.
  + Wenn Sie die Spezifikation der Anmeldeinformationen im SSM Parameter Store speichern, sind IAM-Berechtigungen für den Amazon EC2 Systems Manager Parameter Store für die Rolle der Aufgabenausführung erforderlich.
  + Wenn Sie die Spezifikation der Anmeldeinformationen in Amazon S3 speichern, sind IAM-Berechtigungen für Amazon Simple Storage Service für die Rolle der Aufgabenausführung erforderlich.

## Einrichten von gMSA für Windows-Container auf Amazon ECS
<a name="windows-gmsa-setup"></a>

Um gMSA für Windows-Container auf Amazon ECS einzurichten, können Sie dem vollständigen Tutorial folgen, das auch die Konfiguration der Voraussetzungen beinhaltet, [Verwenden von Amazon ECS-Windows-Containern mit domainless unter gMSA Verwendung von AWS CLI](tutorial-gmsa-windows.md).

In den folgenden Abschnitten wird die CredSpec-Konfiguration im Detail behandelt.

**Topics**
+ [Beispiel-CredSpec](#windows-gmsa-example)
+ [Domainlose gMSA einrichten](#windows-gmsa-domainless)
+ [Referenzieren einer Anmeldeinformations-Spezifikationsdatei in einer Aufgabendefinition](#windows-gmsa-credentialspec)

### Beispiel-CredSpec
<a name="windows-gmsa-example"></a>

Amazon ECS verwendet eine Anmeldespezifikationsdatei, die die gMSA-Metadaten enthält, die verwendet werden, um den gMSA-Kontokontext an den Windows-Container zu übertragen. Sie können die Anmeldeinformations-Spezifikationsdatei generieren und im Feld `credentialSpec` in Ihrer Aufgabendefinition darauf verweisen. Die Anmeldeinformations-Spezifikationsdatei enthält keine Secrets.

Im Folgenden finden Sie eine Beispiel-Anmeldeinformations-Spezifikationsdatei:

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "contoso.com",
        "DnsName": "contoso.com",
        "NetBiosName": "contoso"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "contoso.com"
            }
        ]
    }
}
```

### Domainlose gMSA einrichten
<a name="windows-gmsa-domainless"></a>

Wir empfehlen domainlose gMSA, anstatt die Container-Instances zu einer einzigen Domain zu verbinden. Durch die Verwendung von domainlosen gMSA ist die Container-Instance nicht mit der Domain verbunden, andere Anwendungen auf der Instance können die Anmeldeinformationen nicht verwenden, um auf die Domain zuzugreifen, und Aufgaben, die verschiedenen Domains angehören, können auf derselben Instance ausgeführt werden.

1. Bevor Sie die CredSpec in eine der Speicheroptionen hochladen, fügen Sie Informationen mit dem ARN des Secrets im Secrets Manager oder SSM Parameter Store zur CredSpec hinzu. Weitere Informationen finden Sie unter [Konfiguration zusätzlicher Anmeldeinformationen für den Anwendungsfall non-domain-joined Container-Hosts](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) auf der Microsoft Learn-Website.

**Format der Anmeldeinformationen für domainlose gMSA**  
Das Folgende ist das JSON-Format für die domainlosen gMSA-Anmeldeinformationen für Ihr Active Directory. Speichern Sie die Anmeldeinformationen in Secrets Manager oder SSM Parameter Store.

   ```
   {
       "username":"WebApp01",
       "password":"Test123!",
       "domainName":"contoso.com"
   }
   ```

1. Fügen Sie der CredSpec-Datei in der `ActiveDirectoryConfig` die folgende Information hinzu. Ersetzen Sie den ARN durch das Secret in Secrets Manager oder SSM Parameter Store.

   Beachten Sie, dass der `PluginGUID`-Wert mit der GUID im folgenden Beispielausschnitt übereinstimmen muss und erforderlich ist.

   ```
       "HostAccountConfig": {
           "PortableCcgVersion": "1",
           "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
           "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   Sie können auch ein Secret im SSM Parameter Store verwenden, indem Sie den ARN in diesem Format verwenden: `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`.

1. Nachdem Sie die CredSpec-Datei geändert haben, sollte sie wie im folgenden Beispiel aussehen:

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "WebApp01",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "contoso",
       "DnsName": "contoso",
       "NetBiosName": "contoso"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         },
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

### Referenzieren einer Anmeldeinformations-Spezifikationsdatei in einer Aufgabendefinition
<a name="windows-gmsa-credentialspec"></a>

Amazon ECS unterstützt die folgenden Möglichkeiten, um auf den Dateipfad im `credentialSpecs`-Feld der Aufgabendefinition zu verweisen. Für jede dieser Optionen können Sie `credentialspec:` oder `domainlesscredentialspec:` angeben, je nachdem, ob Sie die Container-Instances zu einer einzigen Domain zusammenfügen oder domainlose gMSA verwenden.

#### Amazon S3 Bucket
<a name="gmsa-credspec-s3"></a>

Fügen Sie die Anmeldeinformationsspezifikation zu einem Amazon S3 Bucket hinzu und verweisen Sie dann im Feld `credentialSpecs` der Aufgabendefinition auf den Amazon-Ressourcennamen (ARN) des Amazon S3 Buckets.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
            ],
            ...
        }
    ],
    ...
}
```

Sie müssen auch die folgenden Berechtigungen als Inline-Richtlinie zur IAM-Rolle der Amazon-ECS-Aufgabenausführung hinzufügen, um Ihren Aufgaben Zugriff auf den Amazon S3 Bucket zu geben.

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "VisualEditor",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::{bucket_name}",
                "arn:aws:s3:::{bucket_name}/{object}"
            ]
        }
    ]
}
```

------

#### SSM-Parameterspeicher-Parameter
<a name="gmsa-credspec-ssm"></a>

Fügen Sie die Anmeldeinformationsspezifikation zu einem SSM-Parameterspeicher-Parameter hinzu und verweisen Sie dann im Feld `credentialSpecs` der Aufgabendefinition auf den Amazon-Ressourcennamen (ARN) des SSM-Parameterspeicher-Parameters.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:ssm:region:111122223333:parameter/parameter_name"
            ],
            ...
        }
    ],
    ...
}
```

Sie müssen außerdem die folgenden Berechtigungen als Inline-Richtlinie zur IAM-Rolle der Amazon-ECS-Aufgabenausführung hinzufügen, um Ihren Aufgaben Zugriff auf den SSM-Parameterspeicher-Parameter zu geben.

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ssm:GetParameters"
            ],
            "Resource": "arn:aws:ssm:*:111122223333:parameter/example*"
        }
    ]
}
```

------

#### Lokale Datei
<a name="gmsa-credspec-file"></a>

Wenn die Daten der Anmeldeinformationsspezifikation in einer lokalen Datei enthalten sind, verweisen Sie auf den Dateipfad im Feld `credentialSpecs` der Aufgabendefinition. Der Dateipfad, auf den verwiesen wird, muss relativ zum `C:\ProgramData\Docker\CredentialSpecs`-Verzeichnis sein und den umgekehrten Schrägstrich („\$1“) als Dateipfadtrennzeichen verwenden.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspec:file://CredentialSpecDir\CredentialSpecFile.json"
            ],
            ...
        }
    ],
    ...
}
```

# Verwenden von EC2 Image Builder zur Erstellung maßgeschneiderter Amazon ECS-optimierter AMIs
<a name="image-builder-tutorial"></a>

AWS empfiehlt die Verwendung der für Amazon ECS optimierten AMIs, da diese mit den Anforderungen und Empfehlungen für die Ausführung Ihrer Container-Workloads vorkonfiguriert sind. Es kann vorkommen, dass Sie Ihr AMI anpassen müssen, um zusätzliche Software hinzuzufügen. Sie können EC2 Image Builder für die Erstellung, Verwaltung und Bereitstellung Ihrer Server-Images verwenden. Sie behalten das Eigentum an den benutzerdefinierten Images, die in Ihrem Konto erstellt wurden. Sie können EC2-Image-Pipelines verwenden, um Aktualisierungen und System-Patches für Ihre Images zu automatisieren, oder einen eigenständigen Befehl verwenden, um ein Image mit Ihren definierten Konfigurationsressourcen zu erstellen.

Sie erstellen ein Rezept für ein Image. Das Rezept enthält ein übergeordnetes Image und alle zusätzlichen Komponenten. Sie erstellen auch eine Pipeline, die Ihr benutzerdefiniertes AMI verteilt.

Sie erstellen ein Rezept für ein Image. Ein Image-Rezept von Image Builder ist ein Dokument, welches das Basis-Image und die auf das Basis-Image anzuwendenden Komponenten definiert, um die gewünschte Konfiguration für das Ausgabe-AMI-Image zu erzeugen. Sie erstellen auch eine Pipeline, die Ihr benutzerdefiniertes AMI verteilt. Weitere Informationen finden Sie [So funktioniert EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/how-image-builder-works.html) im *Benutzerhandbuch für EC2 Image Builder*.

Wir empfehlen, eines der folgenden Amazon-ECS-optimierten AMIs als Ihr „übergeordnetes Image“ in EC2 Image Builder zu verwenden:
+ Linux
  + Amazon ECS-optimiertes x86 AL2023 
  + Amazon-ECS-optimiertes AMI für Amazon Linux 2023 (arm64)
  + Amazon ECS-optimiertes Amazon Linux 2-Kernel-5-AMI
  + Amazon-ECS-optimiertes AMI für Amazon Linux 2 x86
+ Windows
  + Amazon-ECS-optimiertes Windows 2022 Full x86
  + Amazon-ECS-optimiertes Windows 2022 Core x86
  + Amazon-ECS-optimiertes Windows 2019 Full x86
  + Amazon-ECS-optimiertes Windows 2019 Core x86
  + Amazon-ECS-optimiertes Windows 2016 Full x86

Wir empfehlen außerdem, dass Sie „Letzte verfügbare Betriebssystemversion verwenden“ auswählen. Die Pipeline verwendet für das übergeordnete Image eine semantische Versionsverwaltung, die hilft, die Abhängigkeitsupdates in automatisch geplanten Aufträgen zu erkennen. Weitere Informationen finden Sie unter [Semantische Versionsverwaltung](https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html) im *Benutzerhandbuch für EC2 Image Builder*.

AWS aktualisiert regelmäßig Amazon ECS-optimierte AMI-Images mit Sicherheitspatches und der neuen Container-Agent-Version. Wenn Sie eine AMI-ID als übergeordnetes Image in Ihrem Image-Rezept verwenden, müssen Sie regelmäßig nach Aktualisierungen für das übergeordnete Image suchen. Wenn es Updates gibt, müssen Sie eine neue Version Ihres Rezepts mit dem aktualisierten AMI erstellen. Dadurch wird sichergestellt, dass Ihre benutzerdefinierten Images die neueste Version des übergeordneten Image enthalten. Informationen zum Erstellen eines Workflows zur automatischen Aktualisierung Ihrer EC2-Instances in Ihrem Amazon ECS-Cluster mit den neu erstellten AMIs Instances finden Sie unter [So erstellen Sie eine AMI-Hardening-Pipeline und automatisieren Updates für Ihre ECS-Instance-Flotte](https://aws.amazon.com/blogs/security/how-to-create-an-ami-hardening-pipeline-and-automate-updates-to-your-ecs-instance-fleet/).

Sie können auch den Amazon-Ressourcennamen (ARN) eines übergeordneten Images angeben, das über eine verwaltete EC2-Image-Builder-Pipeline veröffentlicht wurde. Amazon veröffentlicht routinemäßig Amazon-ECS-optimierte AMI-Images über verwaltete Pipelines. Diese Images sind öffentlich zugänglich. Sie müssen über die entsprechenden Berechtigungen verfügen, um auf das Image zugreifen zu können. Wenn Sie in Ihrem Image-Builder-Rezept einen Image-ARN anstelle eines AMI verwenden, verwendet Ihre Pipeline bei jeder Ausführung automatisch die neueste Version des übergeordneten Images. Dieser Ansatz macht es überflüssig, für jede Aktualisierung manuell neue Rezeptversionen zu erstellen. 

## Das Amazon-ECS-optimierte AMI bereinigen
<a name="cleanup-ecs-optimized-ami"></a>

Wenn Sie ein Amazon-ECS-optimiertes AMI als übergeordnetes Image verwenden, müssen Sie das Image bereinigen, um vorübergehende Probleme zu vermeiden. Das Amazon-ECS-optimierte AMI ist so vorkonfiguriert, dass der Amazon-ECS-Agent automatisch startet und sich als Container-Instance bei Amazon ECS registriert. Wenn Sie es als Basis-Image ohne ordnungsgemäße Bereinigung verwenden, kann dies zu Problemen in Ihrem benutzerdefinierten AMI führen.

Um das Image für die zukünftige Verwendung zu bereinigen, erstellen Sie eine Komponente, die die folgenden Befehle ausführt, um das ecs-init-Paket und die Docker-Prozesse anzuhalten:

```
sudo systemctl stop ecs
sudo systemctl stop docker
```

Entfernen Sie alle Protokolldateien aus der aktuellen Instance, um zu verhindern, dass sie beim Speichern des Images erhalten bleiben. Verwenden Sie das Beispielskript unter [Bewährte Sicherheitsmethoden für EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/security-best-practices.html), um die verschiedenen Dateien aus der Instance zu bereinigen.

Führen Sie die folgenden Befehle aus, um die Amazon-ECS-spezifischen Daten zu bereinigen:

```
sudo rm -rf /var/log/ecs/*
sudo rm /var/lib/ecs/data/agent.db
```

Weitere Informationen zur Erstellung eines benutzerdefinierten Amazon ECS-optimierten AMIs AMI finden Sie unter [Wie erstelle ich ein benutzerdefiniertes AMI aus einem Amazon ECS-optimierten](https://forums.aws.amazon.com/knowledge-center/ecs-create-custom-amis/) AMI? im Knowledge Center. AWS 

## Verwenden des Image-ARN mit Infrastructure as Code (IaC)
<a name="infrastructure-as-code-arn"></a>

Sie können das Rezept mit der EC2 Image Builder Builder-Konsole, Infrastructure-as-Code (z. B. CloudFormation) oder dem AWS SDK konfigurieren. Wenn Sie in Ihrem Rezept ein übergeordnetes Image angeben, können Sie eine EC2-AMI-ID, einen Image Builder Builder-Image-ARN, eine AWS Marketplace Produkt-ID oder ein Container-Image angeben. AWS veröffentlicht sowohl das AMI IDs - als auch Image Builder Builder-Image ARNs von Amazon ECS-Optimized öffentlich AMIs . Der ARN für das Image hat folgendes Format:

```
arn:${Partition}:imagebuilder:${Region}:${Account}:image/${ImageName}/${ImageVersion}
```

Die `ImageVersion` hat das folgende Format. Ersetzen*major*, *minor* und *patch* mit den neuesten Werten.

```
<major>.<minor>.<patch>
```

Sie können `minor` und `patch` durch bestimmte Werte ersetzen `major` oder Sie können den versionslosen ARN eines Images verwenden, sodass Ihre Pipeline up-to-date bei der neuesten Version des übergeordneten Images bleibt. Ein versionsloser ARN verwendet das Platzhalterformat „x.x.x“, um die Image-Version darzustellen. Dieser Ansatz ermöglicht es dem Image-Builder-Service, automatisch auf die neueste Version des Images aufzulösen. Durch die Verwendung des versionsfreien ARN wird sichergestellt, dass Ihre Referenz immer auf das neueste verfügbare Image verweist, wodurch der Prozess der Aktualisierung von Images in Ihrer Bereitstellung rationalisiert wird. Wenn Sie mit der Konsole ein Rezept erstellen, identifiziert EC2 Image Builder automatisch den ARN für Ihr übergeordnetes Image. Wenn Sie IaC verwenden, um das Rezept zu erstellen, müssen Sie den ARN identifizieren und die gewünschte Image-Version auswählen oder den versionslosen ARN verwenden, um das neueste verfügbare Image anzugeben. Wir empfehlen Ihnen, ein automatisiertes Skript zu erstellen, um nur Images zu filtern und anzuzeigen, die Ihren Kriterien entsprechen. Das folgende Python-Skript zeigt, wie Sie eine Liste von Amazon AMIs ECS-optimierten Dateien abrufen. 

Das Skript akzeptiert zwei optionale Argumente: `owner` und `platform`, mit den Standardwerten „Amazon“ bzw. „Windows“. Die gültigen Werte für das Argument owner sind: `Self`, `Shared`, `Amazon` und `ThirdParty`. Die gültigen Werte für das Argument platform sind `Windows` und `Linux`. Wenn Sie das Skript beispielsweise mit dem Argument `owner` auf `Amazon` gestellt und `platform` auf `Linux` gestellt ausführen, generiert das Skript eine Liste von Images, die von Amazon veröffentlicht wurden, einschließlich Amazon-ECS-optimierter Images.

```
import boto3
import argparse

def list_images(owner, platform):
    # Create a Boto3 session
    session = boto3.Session()
    
    # Create an EC2 Image Builder client
    client = session.client('imagebuilder')

    # Define the initial request parameters
    request_params = {
        'owner': owner,
        'filters': [
            {
                'name': 'platform',
                'values': [platform]
            }
        ]
    }

    # Initialize the results list
    all_images = []

    # Get the initial response with the first page of results
    response = client.list_images(**request_params)

    # Extract images from the response
    all_images.extend(response['imageVersionList'])

    # While 'nextToken' is present, continue paginating
    while 'nextToken' in response and response['nextToken']:
        # Update the token for the next request
        request_params['nextToken'] = response['nextToken']

        # Get the next page of results
        response = client.list_images(**request_params)

        # Extract images from the response
        all_images.extend(response['imageVersionList'])

    return all_images

def main():
    # Initialize the parser
    parser = argparse.ArgumentParser(description="List AWS images based on owner and platform")
    
    # Add the parameters/arguments
    parser.add_argument("--owner", default="Amazon", help="The owner of the images. Default is 'Amazon'.")
    parser.add_argument("--platform", default="Windows", help="The platform type of the images. Default is 'Windows'.")

    # Parse the arguments
    args = parser.parse_args()

    # Retrieve all images based on the provided owner and platform
    images = list_images(args.owner, args.platform)

    # Print the details of the images
    for image in images:
        print(f"Name: {image['name']}, Version: {image['version']}, ARN: {image['arn']}")

if __name__ == "__main__":
    main()
```

## Verwenden des Bild-ARN mit CloudFormation
<a name="arn-with-cloudformation"></a>

Ein Image-Builder-Image-Rezept ist eine Vorlage, die das übergeordnete Image und die Komponenten spezifiziert, die für die beabsichtigte Konfiguration des Ausgabe-Images erforderlich sind. Sie verwenden die `AWS::ImageBuilder::ImageRecipe`-Ressource. Stellen Sie den `ParentImage`-Wert auf den Image-ARN ein. Verwenden Sie den versionslosen ARN Ihres gewünschten Images, um sicherzustellen, dass Ihre Pipeline immer die neueste Version des Images verwendet. Beispiel, `arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x`. Die folgende `AWS::ImageBuilder::ImageRecipe`-Ressourcendefinition verwendet einen von Amazon verwalteten Image ARN:

```
ECSRecipe:
    Type: AWS::ImageBuilder::ImageRecipe
    Properties:
      Name: MyRecipe
      Version: '1.0.0'
      Components:
        - ComponentArn: [<The component arns of the image recipe>]
      ParentImage: "arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x"
```

Weitere Informationen über die [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html)-Ressource finden Sie im *Benutzerhandbuch für AWS CloudFormation *.

Sie können die Erstellung neuer Images in Ihrer Pipeline automatisieren, indem Sie die `Schedule`-Eigenschaft der `AWS::ImageBuilder::ImagePipeline`-Ressource festlegen. Der Zeitplan enthält eine Startbedingung und einen Cron-Ausdruck. Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html) im *AWS CloudFormation -Benutzerhandbuch*.

 Im folgenden Beispiel einer `AWS::ImageBuilder::ImagePipeline` wird für die Pipeline täglich um 10:00 Uhr (UTC) ein Build ausgeführt. Legen Sie die folgenden `Schedule`-Werte fest:
+ Setzen Sie `PipelineExecutionStartCondition` auf `EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. Der Build wird nur gestartet, wenn abhängige Ressourcen wie das übergeordnete Image oder Komponenten, die in ihren semantischen Versionen den Platzhalter „x“ verwenden, aktualisiert werden. Dadurch wird sichergestellt, dass der Build die neuesten Aktualisierungen dieser Ressourcen enthält.
+ Auf ScheduleExpression den Cron-Ausdruck `(0 10 * * ? *)` gesetzt.

```
ECSPipeline:
    Type: AWS::ImageBuilder::ImagePipeline
    Properties:
      Name: my-pipeline
      ImageRecipeArn: <arn of the recipe you created in previous step>
      InfrastructureConfigurationArn: <ARN of the infrastructure configuration associated with this image pipeline>
      Schedule:
        PipelineExecutionStartCondition: EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE
        ScheduleExpression: 'cron(0 10 * * ? *)'
```

## Verwenden des Image-ARN mit Terraform
<a name="arn-with-terraform"></a>

Der Ansatz zur Angabe des übergeordneten Images und des Zeitplans Ihrer Pipeline in Terraform entspricht dem in AWS CloudFormation. Sie verwenden die `aws_imagebuilder_image_recipe`-Ressource. Stellen Sie den `parent_image`-Wert auf den Image-ARN ein. Verwenden Sie den versionslosen ARN Ihres gewünschten Images, um sicherzustellen, dass Ihre Pipeline immer die neueste Version des Images verwendet. Weitere Informationen finden Sie unter [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference) in der Terraform-Dokumentation. 

Setzen Sie im Zeitplan-Konfigurationsblock der `aws_imagebuilder_image_pipeline resource` den `schedule_expression`-Argumentwert auf einen Cron-Ausdruck Ihrer Wahl, um anzugeben, wie oft die Pipeline ausgeführt wird, und setzen Sie `pipeline_execution_start_condition` auf `EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. Weitere Informationen finden Sie unter [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference) in der Terraform-Dokumentation. 

# Verwenden von AWS Deep Learning Containers auf Amazon ECS
<a name="deep-learning-containers"></a>

AWS Deep Learning Containers bieten eine Reihe von Docker-Images für das Training und die Bereitstellung von Modellen in TensorFlow und Apache MXNet (Incubating) auf Amazon ECS. Deep Learning Containers ermöglichen optimierte Umgebungen mit TensorFlow NVIDIA CUDA- (für GPU-Instances) und Intel MKL- (für CPU-Instances) Bibliotheken. Containerbilder für Deep Learning Containers sind in Amazon ECR verfügbar, um in Amazon ECS-Aufgabendefinitionen zu referenzieren. Sie können Deep Learning Containers zusammen mit Amazon Elastic Inference verwenden, um Ihre Inferenzkosten zu senken.

Informationen zu den ersten Schritten mit Deep-Learning-Containers ohne Elastic Inference in Amazon ECS finden Sie unter [Einrichtung von Amazon ECS](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/deep-learning-containers-ecs-setup.html) im *Entwicklerhandbuch für AWS Deep Learning AMIs *.

# Tutorial: Einen Dienst mithilfe einer Bereitstellung erstellen Blue/Green
<a name="create-blue-green"></a>

Amazon ECS hat blue/green Bereitstellungen in den Create Service Wizard auf der Amazon ECS-Konsole integriert. Weitere Informationen finden Sie unter [Erstellung einer Amazon-ECS-Bereitstellung mit fortlaufender Aktualisierung](create-service-console-v2.md).

Das folgende Tutorial zeigt, wie Sie einen Amazon ECS-Service erstellen, der eine Fargate-Aufgabe enthält, die den blue/green Bereitstellungstyp mit dem AWS CLI verwendet.

**Anmerkung**  
Support für die Durchführung einer blue/green Bereitstellung wurde hinzugefügt CloudFormation. Weitere Informationen finden Sie im *AWS CloudFormation Benutzerhandbuch* unter [Durchführen von Blue/Green-Bereitstellungen von Amazon ECS CodeDeploy mithilfe von CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) Amazon ECS.

## Voraussetzungen
<a name="create-blue-green-prereqs"></a>

In diesem Tutorial wird davon ausgegangen, dass Sie die folgenden Voraussetzungen erfüllt haben:
+ Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen zur Installation oder Aktualisierung von finden Sie unter [Installation von AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html). AWS CLI
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
+ Sie haben eine VPC und die zu verwendende Sicherheitsgruppe erstellt. Weitere Informationen finden Sie unter [Erstellen einer Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Die Amazon ECS CodeDeploy IAM-Rolle wird erstellt. Weitere Informationen finden Sie unter [Amazon ECS CodeDeploy IAM-Rolle](codedeploy_IAM_role.md).

## Schritt 1: Erstellen eines Application Load Balancers
<a name="create-blue-green-loadbalancer"></a>

Amazon ECS-Services, die den blue/green Bereitstellungstyp verwenden, erfordern entweder die Verwendung eines Application Load Balancer oder eines Network Load Balancer. In diesem Tutorial wird ein Application Load Balancer verwendet.

**So erstellen Sie einen Application Load Balancer**

1. Verwenden Sie den [create-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-load-balancer.html)Befehl, um einen Application Load Balancer zu erstellen. Geben Sie zwei Subnetze, die sich nicht in derselben Availability Zone befinden, sowie eine Sicherheitsgruppe an.

   ```
   aws elbv2 create-load-balancer \
        --name bluegreen-alb \
        --subnets subnet-abcd1234 subnet-abcd5678 \
        --security-groups sg-abcd1234 \
        --region us-east-1
   ```

   Die Ausgabe enthält den Amazon Resource Name (ARN) des Load Balancers im folgenden Format:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642
   ```

1. Verwenden Sie den [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)Befehl, um eine Zielgruppe zu erstellen. Diese Zielgruppe leitet den Datenverkehr an den ursprünglichen Aufgabesatz in Ihrem Service weiter.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget1 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id vpc-abcd1234 \
        --region us-east-1
   ```

   Die Ausgabe umfasst den ARN der Zielgruppe im folgenden Format:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4
   ```

1. Verwenden Sie den Befehl [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html), um einen Listener für Ihren Load Balancer mit einer Standardregel zu erstellen, die Anforderungen an Ihre Zielgruppe weiterleitet.

   ```
   aws elbv2 create-listener \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --protocol HTTP \
        --port 80 \
        --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   Die Ausgabe enthält den ARN des Listener im folgenden Format:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4
   ```

## Schritt 2: Eine Amazon-ECS-Cluster erstellen
<a name="create-blue-green-cluster"></a>

Verwenden Sie den Befehl [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-cluster.html), um einen Cluster namens `tutorial-bluegreen-cluster` zu erstellen.

```
aws ecs create-cluster \
     --cluster-name tutorial-bluegreen-cluster \
     --region us-east-1
```

Die Ausgabe enthält den ARN des Clusters im folgenden Format:

```
arn:aws:ecs:region:aws_account_id:cluster/tutorial-bluegreen-cluster
```

## Schritt 3: Registrieren einer Aufgabendefinition
<a name="create-blue-green-taskdef"></a>

Verwenden Sie den [register-task-definition](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html)Befehl, um eine Aufgabendefinition zu registrieren, die mit Fargate kompatibel ist. Für sie muss als Netzwerkmodus `awsvpc` verwendet werden. Nachfolgend finden Sie die Beispiel-Aufgabendefinition, die für dieses Tutorial verwendet wurde.

Erstellen Sie zuerst eine Datei mit dem Namen `fargate-task.json` und dem folgenden Inhalt. Stellen Sie sicher, dass Sie den ARN für die Aufgabenausführungsrolle verwenden. Weitere Informationen finden Sie unter [IAM-Rolle für die Amazon-ECS-Aufgabenausführung](task_execution_IAM_role.md).

```
{
    "family": "sample-fargate", 
    "networkMode": "awsvpc", 
    "containerDefinitions": [
        {
            "name": "sample-app", 
            "image": "public.ecr.aws/docker/library/httpd:latest", 
            "portMappings": [
                {
                    "containerPort": 80, 
                    "hostPort": 80, 
                    "protocol": "tcp"
                }
            ], 
            "essential": true, 
            "entryPoint": [
                "sh",
		"-c"
            ], 
            "command": [
                "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
            ]
        }
    ], 
    "requiresCompatibilities": [
        "FARGATE"
    ], 
    "cpu": "256", 
    "memory": "512"
}
```

Registrieren Sie dann die Aufgabendefinition mit der von Ihnen erstellten Datei `fargate-task.json`.

```
aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1
```

## Schritt 4: Einen Amazon-ECS-Service erstellen
<a name="create-blue-green-service"></a>

Verwenden Sie den Befehl [create-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html), um einen Service zu erstellen. 

Erstellen Sie zuerst eine Datei mit dem Namen `service-bluegreen.json` und dem folgenden Inhalt.

```
{
    "cluster": "tutorial-bluegreen-cluster",
    "serviceName": "service-bluegreen",
    "taskDefinition": "tutorial-task-def",
    "loadBalancers": [
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4",
            "containerName": "sample-app",
            "containerPort": 80
        }
    ],
    "launchType": "FARGATE",
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "CODE_DEPLOY"
    },
    "platformVersion": "LATEST",
    "networkConfiguration": {
       "awsvpcConfiguration": {
          "assignPublicIp": "ENABLED",
          "securityGroups": [ "sg-abcd1234" ],
          "subnets": [ "subnet-abcd1234", "subnet-abcd5678" ]
       }
    },
    "desiredCount": 1
}
```

Erstellen Sie dann Ihren Service unter Verwendung der Datei `service-bluegreen.json`, die Sie erstellt haben.

```
aws ecs create-service \
     --cli-input-json file://service-bluegreen.json \
     --region us-east-1
```

Die Ausgabe enthält den ARN des Service im folgenden Format:

```
arn:aws:ecs:region:aws_account_id:service/service-bluegreen
```

## Schritt 5: Erstellen Sie die Ressourcen AWS CodeDeploy
<a name="create-blue-green-codedeploy"></a>

Gehen Sie wie folgt vor, um Ihre CodeDeploy Anwendung, die Application Load Balancer Balancer-Zielgruppe für die CodeDeploy Bereitstellungsgruppe und die CodeDeploy Bereitstellungsgruppe zu erstellen.

**Um Ressourcen zu erstellen CodeDeploy**

1. Verwenden Sie den Befehl [create-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-application.html), um eine CodeDeploy Anwendung zu erstellen. Geben Sie die `ECS`-Plattform für die Datenverarbeitung an.

   ```
   aws deploy create-application \
        --application-name tutorial-bluegreen-app \
        --compute-platform ECS \
        --region us-east-1
   ```

   Die Ausgabe enthält die Anwendungs-ID im folgenden Format:

   ```
   {
       "applicationId": "b8e9c1ef-3048-424e-9174-885d7dc9dc11"
   }
   ```

1. Verwenden Sie den [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)Befehl, um eine zweite Application Load Balancer Balancer-Zielgruppe zu erstellen, die bei der Erstellung Ihrer CodeDeploy Bereitstellungsgruppe verwendet wird.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget2 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id "vpc-0b6dd82c67d8012a1" \
        --region us-east-1
   ```

   Die Ausgabe umfasst den ARN der Zielgruppe im folgenden Format:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc
   ```

1. Verwenden Sie den [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)Befehl, um eine CodeDeploy Bereitstellungsgruppe zu erstellen.

   Erstellen Sie zuerst eine Datei mit dem Namen `tutorial-deployment-group.json` und dem folgenden Inhalt. Dieses Beispiel verwendet die von Ihnen erstellte Ressource. Geben Sie für die `serviceRoleArn` den ARN Ihrer Amazon CodeDeploy ECS-IAM-Rolle an. Weitere Informationen finden Sie unter [Amazon ECS CodeDeploy IAM-Rolle](codedeploy_IAM_role.md).

   ```
   {
      "applicationName": "tutorial-bluegreen-app",
      "autoRollbackConfiguration": {
         "enabled": true,
         "events": [ "DEPLOYMENT_FAILURE" ]
      },
      "blueGreenDeploymentConfiguration": {
         "deploymentReadyOption": {
            "actionOnTimeout": "CONTINUE_DEPLOYMENT",
            "waitTimeInMinutes": 0
         },
         "terminateBlueInstancesOnDeploymentSuccess": {
            "action": "TERMINATE",
            "terminationWaitTimeInMinutes": 5
         }
      },
      "deploymentGroupName": "tutorial-bluegreen-dg",
      "deploymentStyle": {
         "deploymentOption": "WITH_TRAFFIC_CONTROL",
         "deploymentType": "BLUE_GREEN"
      },
      "loadBalancerInfo": {
         "targetGroupPairInfoList": [
           {
             "targetGroups": [
                {
                    "name": "bluegreentarget1"
                },
                {
                    "name": "bluegreentarget2"
                }
             ],
             "prodTrafficRoute": {
                 "listenerArns": [
                     "arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4"
                 ]
             }
           }
         ]
      },
      "serviceRoleArn": "arn:aws:iam::aws_account_id:role/ecsCodeDeployRole",
      "ecsServices": [
          {
              "serviceName": "service-bluegreen",
              "clusterName": "tutorial-bluegreen-cluster"
          }
      ]
   }
   ```

   Erstellen Sie dann die CodeDeploy Bereitstellungsgruppe.

   ```
   aws deploy create-deployment-group \
        --cli-input-json file://tutorial-deployment-group.json \
        --region us-east-1
   ```

   Die Ausgabe enthält die Bereitstellungsgruppen-ID im folgenden Format:

   ```
   {
       "deploymentGroupId": "6fd9bdc6-dc51-4af5-ba5a-0a4a72431c88"
   }
   ```

## Schritt 6: Eine CodeDeploy Bereitstellung erstellen und überwachen
<a name="create-blue-green-verify"></a>

Gehen Sie wie folgt vor, um eine Anwendungsspezifikationsdatei (AppSpec Datei) und eine CodeDeploy Bereitstellung zu erstellen und hochzuladen.

**Um eine CodeDeploy Bereitstellung zu erstellen und zu überwachen**

1. Gehen Sie wie folgt vor, um eine AppSpec Datei zu erstellen und hochzuladen.

   1. Erstellen Sie eine Datei mit dem Namen `appspec.yaml` und dem Inhalt der CodeDeploy -Bereitstellungsgruppe. Dieses Beispiel verwendet die Ressourcen, die Sie zuvor im Tutorial erstellt haben.

      ```
      version: 0.0
      Resources:
        - TargetService:
            Type: AWS::ECS::Service
            Properties:
              TaskDefinition: "arn:aws:ecs:region:aws_account_id:task-definition/first-run-task-definition:7"
              LoadBalancerInfo:
                ContainerName: "sample-app"
                ContainerPort: 80
              PlatformVersion: "LATEST"
      ```

   1. Verwenden Sie den Befehl [s3 mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html), um einen Amazon S3 S3-Bucket für die AppSpec Datei zu erstellen.

      ```
      aws s3 mb s3://tutorial-bluegreen-bucket
      ```

   1. Verwenden Sie den Befehl [s3 cp](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html), um die AppSpec Datei in den Amazon S3 S3-Bucket hochzuladen.

      ```
      aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml
      ```

1. Erstellen Sie die CodeDeploy Bereitstellung mithilfe der folgenden Schritte.

   1. Erstellen Sie eine Datei `create-deployment.json` mit dem Namen des Inhalts der CodeDeploy Bereitstellung. Dieses Beispiel verwendet die Ressourcen, die Sie zuvor im Tutorial erstellt haben.

      ```
      {
          "applicationName": "tutorial-bluegreen-app",
          "deploymentGroupName": "tutorial-bluegreen-dg",
          "revision": {
              "revisionType": "S3",
              "s3Location": {
                  "bucket": "tutorial-bluegreen-bucket",
                  "key": "appspec.yaml",
                  "bundleType": "YAML"
              }
          }
      }
      ```

   1. Verwenden Sie den Befehl [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) zum Erstellen der Bereitstellung.

      ```
      aws deploy create-deployment \
           --cli-input-json file://create-deployment.json \
           --region us-east-1
      ```

      Die Ausgabe enthält die Bereitstellungs-ID im folgenden Format:

      ```
      {
          "deploymentId": "d-RPCR1U3TW"
      }
      ```

   1. Verwenden Sie den [get-deployment-target](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-target.html)Befehl, um die Details der Bereitstellung abzurufen, und geben Sie dabei die Daten `deploymentId` aus der vorherigen Ausgabe an.

      ```
      aws deploy get-deployment-target \
           --deployment-id "d-IMJU3A8TW" \
           --target-id tutorial-bluegreen-cluster:service-bluegreen \
           --region us-east-1
      ```

      Fahren Sie mit dem Abrufen der Bereitstellungsdetails fort, bis der Status `Succeeded` lautet, wie in der folgenden Ausgabe dargestellt.

      ```
      {
          "deploymentTarget": {
              "deploymentTargetType": "ECSTarget",
              "ecsTarget": {
                  "deploymentId": "d-RPCR1U3TW",
                  "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
                  "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
                  "lastUpdatedAt": 1543431490.226,
                  "lifecycleEvents": [
                      {
                          "lifecycleEventName": "BeforeInstall",
                          "startTime": 1543431361.022,
                          "endTime": 1543431361.433,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "Install",
                          "startTime": 1543431361.678,
                          "endTime": 1543431485.275,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterInstall",
                          "startTime": 1543431485.52,
                          "endTime": 1543431486.033,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "BeforeAllowTraffic",
                          "startTime": 1543431486.838,
                          "endTime": 1543431487.483,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AllowTraffic",
                          "startTime": 1543431487.748,
                          "endTime": 1543431488.488,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterAllowTraffic",
                          "startTime": 1543431489.152,
                          "endTime": 1543431489.885,
                          "status": "Succeeded"
                      }
                  ],
                  "status": "Succeeded",
                  "taskSetsInfo": [
                      {
                          "identifer": "ecs-svc/9223370493425779968",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "ACTIVE",
                          "trafficWeight": 0.0,
                          "targetGroup": {
                              "name": "bluegreentarget1"
                          }
                      },
                      {
                          "identifer": "ecs-svc/9223370493423413672",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "PRIMARY",
                          "trafficWeight": 100.0,
                          "targetGroup": {
                              "name": "bluegreentarget2"
                          }
                      }
                  ]
              }
          }
      }
      ```

## Schritt 7: Bereinigen
<a name="create-blue-green-cleanup"></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.

**Bereinigen der Ressourcen des Tutorials**

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 tutorial-bluegreen-app \
        --deployment-group-name tutorial-bluegreen-dg \
        --region us-east-1
   ```

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 tutorial-bluegreen-app \
        --region us-east-1
   ```

1. Verwenden Sie den Befehl [delete-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-service.html), um den Amazon-ECS-Service zu löschen. Mit dem `--force`-Flag können Sie einen Service auch dann löschen, wenn er nicht auf null Aufgaben herunterskaliert wurde.

   ```
   aws ecs delete-service \
        --service arn:aws:ecs:region:aws_account_id:service/service-bluegreen \
        --force \
        --region us-east-1
   ```

1. Verwenden Sie den Befehl [delete-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-cluster.html), um den Amazon-ECS-Cluster zu löschen.

   ```
   aws ecs delete-cluster \
        --cluster tutorial-bluegreen-cluster \
        --region us-east-1
   ```

1. Verwenden Sie den Befehl [s3 rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html), um die AppSpec Datei aus dem Amazon S3 S3-Bucket zu löschen.

   ```
   aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml
   ```

1. Verwenden Sie den Befehl [s3 rb](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html) zum Löschen des Amazon S3-Buckets.

   ```
   aws s3 rb s3://tutorial-bluegreen-bucket
   ```

1. Verwenden Sie den [delete-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-load-balancer.html)Befehl, um den Application Load Balancer zu löschen.

   ```
   aws elbv2 delete-load-balancer \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --region us-east-1
   ```

1. Verwenden Sie den [delete-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-target-group.html)Befehl, um die beiden Application Load Balancer Balancer-Zielgruppen zu löschen.

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc \
        --region us-east-1
   ```