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.

# 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
```