

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Esempio di definizione di attività di Amazon ECS
<a name="example_task_definitions"></a>

È possibile copiare gli esempi e i frammenti per iniziare a creare le proprie definizioni di attività. 

Puoi copiare gli esempi e incollarli quando utilizzi l'opzione **Configura tramite JSON** nella console. Assicurati di personalizzare gli esempi, ad esempio l'utilizzo del tuo ID account. Puoi includere i frammenti di codice nella definizione dell'attività JSON. Per ulteriori informazioni, consultare [Creazione di una definizione di attività di Amazon ECS attraverso la nuova console](create-task-definition.md) e [Parametri di definizione di attività Amazon ECS per Fargate](task_definition_parameters.md).

Per altri esempi di definizione delle attività, consulta [AWS Esempi di definizioni delle attività](https://github.com/aws-samples/aws-containers-task-definitions) su. GitHub

**Topics**
+ [

## Server Web
](#example_task_definition-webserver)
+ [

## Driver di log `splunk`
](#example_task_definition-splunk)
+ [

## Driver di log `fluentd`
](#example_task_definition-fluentd)
+ [

## Driver di log `gelf`
](#example_task_definition-gelf)
+ [

## Carichi di lavoro su istanze esterne
](#ecs-anywhere-runtask)
+ [

## Immagine Amazon ECR e ruolo IAM della definizione di attività
](#example_task_definition-iam)
+ [

## Punto di ingresso con comando
](#example_task_definition-ping)
+ [

## Dipendenze per i container
](#example_task_definition-containerdependency)
+ [

## Volumi nelle definizioni di attività
](#volume_sample_task_defs)
+ [

## Definizioni di attività di esempio di Windows
](#windows_sample_task_defs)

## Server Web
<a name="example_task_definition-webserver"></a>

Di seguito è riportato un esempio di definizione di attività usando container Linux su Fargate che configura un server Web:

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

Di seguito è riportato un esempio di definizione di attività usando container Windows sul Fargate che configura un server Web:

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

## Driver di log `splunk`
<a name="example_task_definition-splunk"></a>

Il frammento di codice seguente mostra come utilizzare il driver di log `splunk` in una definizione di attività che invia i log a un servizio remoto. Il parametro di token Splunk è specificato come opzione segreta perché può essere trattato come dati sensibili. Per ulteriori informazioni, consulta [Trasferimento di dati sensibili a un container Amazon ECS](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"
}],
```

## Driver di log `fluentd`
<a name="example_task_definition-fluentd"></a>

Il frammento di codice seguente mostra come utilizzare il driver di log `fluentd` in una definizione di attività che invia i log a un servizio remoto. Il valore `fluentd-address` è specificato come opzione segreta perché può essere trattato come dati sensibili. Per ulteriori informazioni, consulta [Trasferimento di dati sensibili a un container Amazon ECS](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
	}]
}],
```

## Driver di log `gelf`
<a name="example_task_definition-gelf"></a>

Il frammento di codice seguente mostra come utilizzare il driver di log `gelf` in una definizione di attività che invia i log a un host remoto. Tale host esegue Logstash e accetta i log di Gelf come input. Per ulteriori informazioni, consulta [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
		}
	]
}],
```

## Carichi di lavoro su istanze esterne
<a name="ecs-anywhere-runtask"></a>

Durante la registrazione di una definizione di attività di Amazon ECS, utilizza il parametro `requiresCompatibilities` e specifica `EXTERNAL`che verifica che la definizione di attività è compatibile per l'uso durante l'esecuzione di carichi di lavoro Amazon ECS sulle istanze esterne. Se registri una definizione di attività tramite la console, devi utilizzare l'editor JSON. Per ulteriori informazioni, consulta [Creazione di una definizione di attività di Amazon ECS attraverso la nuova console](create-task-definition.md).

**Importante**  
Se i processi richiedono un ruolo IAM di esecuzione del processo, assicurati che sia specificato nella definizione di attività. 

Quando distribuisci il tuo carico di lavoro, utilizza il tipo di avvio `EXTERNAL` durante la creazione del servizio o l'esecuzione del processo autonomo.

Di seguito è riportata una definizione di tabella di esempio.

------
#### [ 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"
}
```

------

## Immagine Amazon ECR e ruolo IAM della definizione di attività
<a name="example_task_definition-iam"></a>

Il frammento di codice seguente utilizza un'immagine Amazon ECR denominata `aws-nodejs-sample` con il tag `v1` dal registro `123456789012.dkr.ecr.us-west-2.amazonaws.com`. Il container in questo processo eredita le autorizzazioni IAM dal ruolo `arn:aws:iam::123456789012:role/AmazonECSTaskS3BucketRole`. Per ulteriori informazioni, consulta [Ruolo IAM dell'attività 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"
}
```

## Punto di ingresso con comando
<a name="example_task_definition-ping"></a>

Il frammento di codice seguente mostra la sintassi per un container Docker che utilizza un punto di ingresso e un argomento del comando. Questo container esegue il ping di `example.com` quattro volte e quindi si chiude.

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

## Dipendenze per i container
<a name="example_task_definition-containerdependency"></a>

Questo frammento di codice mostra la sintassi di una definizione di attività con più container in cui è specificata la dipendenza per il container. Nella seguente definizione di attività, il container `envoy` deve raggiungere un stato di integrità, determinato dai parametri richiesti per il controllo dell'integrità, prima che il container `app` venga avviato. Per ulteriori informazioni, consulta [Dipendenze per i container](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"
}
```

## Volumi nelle definizioni di attività
<a name="volume_sample_task_defs"></a>

Usare quanto segue per capire come specificare i volumi nelle attività.
+ Per informazioni sulla configurazione di un volume Amazon EBS, consultare [Specificare la configurazione del volume Amazon EBS nell'implementazione di Amazon ECS](configure-ebs-volume.md).
+ Per informazioni sulla configurazione di un volume Amazon EFS, consultare [Configurazione dei file system Amazon EFS per Amazon ECS utilizzando la console](tutorial-efs-volumes.md).
+ Per informazioni su come configurare un volume FSx per Windows File Server, vedere[Scopri come configurare FSx i file system Windows File Server per Amazon ECS](tutorial-wfsx-volumes.md).
+ Per informazioni sulla configurazione di un volume docker, consultare [Esempi di volumi Docker per Amazon ECS](docker-volume-examples.md).
+ Per informazioni sulla come configurare un montaggio vincolato, consultare [Esempi di montaggio vincolato per Amazon ECS](bind-mount-examples.md).

## Definizioni di attività di esempio di Windows
<a name="windows_sample_task_defs"></a>

Di seguito è riportata una definizione di attività di esempio che consente di iniziare a utilizzare i container Windows su Amazon ECS.

**Example Applicazione di esempio della console Amazon ECS per Windows**  
La seguente definizione di attività è l'applicazione di esempio della console Amazon ECS che viene prodotta nella procedura guidata per la prima esecuzione di Amazon ECS; è stata esportata per utilizzare l'immagine del container Windows `microsoft/iis`.  

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