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-Aufgabe für EC2 mit dem AWS CLI
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
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
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
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
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
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
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
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
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
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
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
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
**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:
```
Welcome to nginx!
...
Welcome to nginx!
If you can see this page, the nginx web server is successfully installed and working.
...
```
Die nginx-Willkommensseite bestätigt, dass Ihr Service erfolgreich ausgeführt wird und über das Internet zugänglich ist.
## Bereinigen von Ressourcen
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"
}
}
```