

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.

# Beispiele für Amazon-ECS-Aufgabendefinitionen
<a name="example_task_definitions"></a>

Sie können die Beispiele und Ausschnitte kopieren, um mit der Erstellung Ihrer eigenen Aufgabendefinitionen zu beginnen. 

Sie können die Beispiele kopieren und dann einfügen, wenn Sie die Option **Über JSON konfigurieren** in der Konsole verwenden. Stellen Sie sicher, dass Sie die Beispiele anpassen, z. B. durch die Verwendung Ihrer Konto-ID. Sie können die Ausschnitte in Ihre JSON-Aufgabendefinition aufnehmen. Weitere Informationen erhalten Sie unter [Erstellen einer Amazon-ECS-Aufgabendefinition mit der Konsole](create-task-definition.md) und [Amazon-ECS-Aufgabendefinitionsparameter für Fargate](task_definition_parameters.md).

Weitere Beispiele für Aufgabendefinitionen finden Sie unter [AWS Beispiel-Aufgabendefinitionen](https://github.com/aws-samples/aws-containers-task-definitions) auf GitHub.

**Topics**
+ [

## Webserver
](#example_task_definition-webserver)
+ [

## `splunk`-Protokolltreiber
](#example_task_definition-splunk)
+ [

## `fluentd`-Protokolltreiber
](#example_task_definition-fluentd)
+ [

## `gelf`-Protokolltreiber
](#example_task_definition-gelf)
+ [

## Workloads auf externen Instances
](#ecs-anywhere-runtask)
+ [

## Amazon-ECR-Image und Aufgabendefinitions-IAM-Rolle
](#example_task_definition-iam)
+ [

## Einstiegspunkt mit Befehl
](#example_task_definition-ping)
+ [

## Container-Abhängigkeit
](#example_task_definition-containerdependency)
+ [

## Volumes in Aufgabendefinitionen
](#volume_sample_task_defs)
+ [

## Beispiele für Windows-Aufgabendefinitionen
](#windows_sample_task_defs)

## Webserver
<a name="example_task_definition-webserver"></a>

Nachfolgend finden Sie ein Beispiel einer Aufgabendefinitionen mit Linux-Containern in Fargate zum Einrichten eines Webservers:

```
{
   "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" 
    ]
}
```

Nachfolgend finden Sie ein Beispiele einer Aufgabendefinitionen mit Windows-Containern in Fargate zum Einrichten eines Webservers:

```
{
    "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"]
}
```

## `splunk`-Protokolltreiber
<a name="example_task_definition-splunk"></a>

Im folgenden Ausschnitt wird gezeigt, wie Sie den `splunk`-Protokolltreiber in einer Aufgabendefinition verwenden, die die Protokolle an einen Remote-Service sendet. Der Splunk-Token-Parameter wird als geheime Option angegeben, da er als sensible Daten behandelt werden kann. Weitere Informationen finden Sie unter [Sensible Daten an einen Amazon-ECS-Container übergeben](specifying-sensitive-data.md).

```
"containerDefinitions": [{
		"logConfiguration": {
			"logDriver": "splunk",
			"options": {
				"splunk-url": "https://cloud.splunk.com:8080",
				"tag": "tag_name",
			},
			"secretOptions": [{
				"name": "splunk-token",
				"valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:splunk-token-KnrBkD"
}],
```

## `fluentd`-Protokolltreiber
<a name="example_task_definition-fluentd"></a>

Im folgenden Ausschnitt wird gezeigt, wie Sie den `fluentd`-Protokolltreiber in einer Aufgabendefinition verwenden, die die Protokolle an einen Remote-Service sendet. Der `fluentd-address`-Wert ist als geheime Option angegeben, da er als sensible Daten behandelt werden kann. Weitere Informationen finden Sie unter [Sensible Daten an einen Amazon-ECS-Container übergeben](specifying-sensitive-data.md).

```
"containerDefinitions": [{
	"logConfiguration": {
		"logDriver": "fluentd",
		"options": {
			"tag": "fluentd demo"
		},
		"secretOptions": [{
			"name": "fluentd-address",
			"valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:fluentd-address-KnrBkD"
		}]
	},
	"entryPoint": [],
	"portMappings": [{
             "hostPort": 80,
             "protocol": "tcp",
             "containerPort": 80
             },
             {
		"hostPort": 24224,
		"protocol": "tcp",
		"containerPort": 24224
	}]
}],
```

## `gelf`-Protokolltreiber
<a name="example_task_definition-gelf"></a>

Im folgenden Ausschnitt wird gezeigt, wie Sie den `gelf`-Protokolltreiber in einer Aufgabendefinition verwenden, die Protokolle an einen Remote-Host sendet, auf dem Logstash ausgeführt wird und Gelf-Protokolle als Eingang verwendet werden. Weitere Informationen finden Sie unter [logConfiguration](task_definition_parameters.md#ContainerDefinition-logConfiguration).

```
"containerDefinitions": [{
	"logConfiguration": {
		"logDriver": "gelf",
		"options": {
			"gelf-address": "udp://logstash-service-address:5000",
			"tag": "gelf task demo"
		}
	},
	"entryPoint": [],
	"portMappings": [{
			"hostPort": 5000,
			"protocol": "udp",
			"containerPort": 5000
		},
		{
			"hostPort": 5000,
			"protocol": "tcp",
			"containerPort": 5000
		}
	]
}],
```

## Workloads auf externen Instances
<a name="ecs-anywhere-runtask"></a>

Verwenden Sie bei der Registrierung einer Amazon-ECS-Aufgabendefinition den `requiresCompatibilities`-Parameter und geben Sie `EXTERNAL` an, der überprüft, ob die Aufgabendefinition kompatibel ist, wenn Amazon-ECS-Workloads auf Ihren externen Instances ausgeführt werden. Wenn Sie die Konsole für die Registrierung einer Aufgabendefinition verwenden, müssen Sie den JSON-Editor verwenden. Weitere Informationen finden Sie unter [Erstellen einer Amazon-ECS-Aufgabendefinition mit der Konsole](create-task-definition.md).

**Wichtig**  
Wenn für Ihre Aufgaben eine IAM-Rolle zur Aufgabenausführung erforderlich ist, stellen Sie sicher, dass diese in der Aufgabendefinition angegeben ist. 

Wenn Sie Ihren Workload bereitstellen, verwenden Sie den `EXTERNAL`-Starttyp, wenn Sie Ihren Service erstellen oder Ihre eigenständige Aufgabe ausführen.

Im Folgenden finden Sie eine Beispielaufgabendefinition.

------
#### [ Linux ]

```
{
	"requiresCompatibilities": [
		"EXTERNAL"
	],
	"containerDefinitions": [{
		"name": "nginx",
		"image": "public.ecr.aws/nginx/nginx:latest",
		"memory": 256,
		"cpu": 256,
		"essential": true,
		"portMappings": [{
			"containerPort": 80,
			"hostPort": 8080,
			"protocol": "tcp"
		}]
	}],
	"networkMode": "bridge",
	"family": "nginx"
}
```

------
#### [ Windows ]

```
{
	"requiresCompatibilities": [
		"EXTERNAL"
	],
	"containerDefinitions": [{
		"name": "windows-container",
		"image": "mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019",
		"memory": 256,
		"cpu": 512,
		"essential": true,
		"portMappings": [{
			"containerPort": 80,
			"hostPort": 8080,
			"protocol": "tcp"
		}]
	}],
	"networkMode": "bridge",
	"family": "windows-container"
}
```

------

## Amazon-ECR-Image und Aufgabendefinitions-IAM-Rolle
<a name="example_task_definition-iam"></a>

Im folgenden Ausschnitt wird ein Amazon-ECR-Image namens `aws-nodejs-sample` mit dem Tag `v1` von der `123456789012.dkr.ecr.us-west-2.amazonaws.com`-Registrierung verwendet. Der Container in dieser Aufgabe erbt die IAM-Berechtigungen von der Rolle `arn:aws:iam::123456789012:role/AmazonECSTaskS3BucketRole`. Weitere Informationen finden Sie unter [Aufgaben-IAM-Rolle für Amazon ECS](task-iam-roles.md).

```
{
    "containerDefinitions": [
        {
            "name": "sample-app",
            "image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/aws-nodejs-sample:v1",
            "memory": 200,
            "cpu": 10,
            "essential": true
        }
    ],
    "family": "example_task_3",
    "taskRoleArn": "arn:aws:iam::123456789012:role/AmazonECSTaskS3BucketRole"
}
```

## Einstiegspunkt mit Befehl
<a name="example_task_definition-ping"></a>

Im folgenden Ausschnitt wird die Syntax eines Docker-Containers gezeigt, der einen Eintrittspunkt und ein Befehlsargument verwendet. Dieser Container führt viermal einen Ping für `example.com` aus und wird dann beendet.

```
{
    "containerDefinitions": [
        {
            "memory": 32,
            "essential": true,
            "entryPoint": ["ping"],
            "name": "alpine_ping",
            "readonlyRootFilesystem": true,
            "image": "alpine:3.4",
            "command": [
                "-c",
                "4",
                "example.com"
            ],
            "cpu": 16
        }
    ],
    "family": "example_task_2"
}
```

## Container-Abhängigkeit
<a name="example_task_definition-containerdependency"></a>

Dieser Ausschnitt veranschaulicht die Syntax einer Aufgabendefinition mit mehreren Containern, für die eine Container-Abhängigkeit angegeben ist. In der folgenden Aufgabendefinition muss der `envoy`-Container einen fehlerfreien Status erreichen. Dieser wird anhand der erforderlichen Container-Parameter für die Zustandsprüfung bestimmt, bevor der `app`-Container gestartet wird. Weitere Informationen finden Sie unter [Container-Abhängigkeit](task_definition_parameters.md#container_definition_dependson).

```
{
  "family": "appmesh-gateway",
  "runtimePlatform": {
        "operatingSystemFamily": "LINUX"
  },
  "proxyConfiguration":{
      "type": "APPMESH",
      "containerName": "envoy",
      "properties": [
          {
              "name": "IgnoredUID",
              "value": "1337"
          },
          {
              "name": "ProxyIngressPort",
              "value": "15000"
          },
          {
              "name": "ProxyEgressPort",
              "value": "15001"
          },
          {
              "name": "AppPorts",
              "value": "9080"
          },
          {
              "name": "EgressIgnoredIPs",
              "value": "169.254.170.2,169.254.169.254"
          }
      ]
  },
  "containerDefinitions": [
    {
      "name": "app",
      "image": "application_image",
      "portMappings": [
        {
          "containerPort": 9080,
          "hostPort": 9080,
          "protocol": "tcp"
        }
      ],
      "essential": true,
      "dependsOn": [
        {
          "containerName": "envoy",
          "condition": "HEALTHY"
        }
      ]
    },
    {
      "name": "envoy",
      "image": "840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.15.1.0-prod",
      "essential": true,
      "environment": [
        {
          "name": "APPMESH_VIRTUAL_NODE_NAME",
          "value": "mesh/meshName/virtualNode/virtualNodeName"
        },
        {
          "name": "ENVOY_LOG_LEVEL",
          "value": "info"
        }
      ],
      "healthCheck": {
        "command": [
          "CMD-SHELL",
          "echo hello"
        ],
        "interval": 5,
        "timeout": 2,
        "retries": 3
      }    
    }
  ],
  "executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
  "networkMode": "awsvpc"
}
```

## Volumes in Aufgabendefinitionen
<a name="volume_sample_task_defs"></a>

Im Folgenden erfahren Sie, wie Volumes in Aufgaben angegeben werden.
+ Informationen zur Konfiguration eines Amazon-EBS-Volumes finden Sie unter [Die Amazon-EBS-Volume-Konfiguration bei der Amazon-ECS-Bereitstellung angeben](configure-ebs-volume.md).
+ Informationen zur Konfiguration eines Amazon-EFS-Volumes finden Sie unter [Konfiguration von Amazon-EFS-Dateisystemen für Amazon ECS mit der Konsole](tutorial-efs-volumes.md).
+ Informationen zur Konfiguration eines Volumes FSx für Windows-Dateiserver finden Sie unter[Erfahren Sie, wie Sie Dateisysteme FSx für Windows File Server für Amazon ECS konfigurieren](tutorial-wfsx-volumes.md).
+ Informationen zur Konfiguration eines Docker-Volumes finden Sie unter [Besipiel-Docker-Volumes für Amazon ECS](docker-volume-examples.md).
+ Informationen zur Konfiguration eines Bind-Mounts finden Sie unter [Beispiele für Bind-Mounts für Amazon ECS](bind-mount-examples.md).

## Beispiele für Windows-Aufgabendefinitionen
<a name="windows_sample_task_defs"></a>

Nachfolgend finden Sie eine exemplarische Aufgabendefinition, die Ihnen den Einstieg in die Verwendung von Windows-Containern auf Amazon ECS erleichtert.

**Example Amazon-ECS-Beispielkonsolenanwendung für Windows**  
Die folgende Aufgabendefinition ist die Amazon-ECS-Beispielkonsolenanwendung, die im zuerst ausgeführten Assistenten für Amazon ECS erzeugt wird. Sie wurde portiert, um das `microsoft/iis` Windows-Container-Image zu verwenden.  

```
{
  "family": "windows-simple-iis",
  "containerDefinitions": [
    {
      "name": "windows_sample_app",
      "image": "mcr.microsoft.com/windows/servercore/iis",
      "cpu": 1024,
      "entryPoint":["powershell", "-Command"],
      "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"],
      "portMappings": [
        {
          "protocol": "tcp",
          "containerPort": 80
        }
      ],
      "memory": 1024,
      "essential": true
    }
  ],
  "networkMode": "awsvpc",
  "memory": "1024",
  "cpu": "1024"
}
```