

# Ejemplo de definiciones de tareas de Amazon ECS
<a name="example_task_definitions"></a>

Puede copiar los ejemplos y fragmentos de código para comenzar a crear sus propias definiciones de tareas. 

Puede copiar los ejemplos y, a continuación, pegarlos cuando utilice la opción **Configurar mediante JSON** en la consola. Asegúrese de personalizar los ejemplos, como usar el ID de su cuenta. Puede incluir los fragmentos en el JSON de definición de tareas. Para obtener más información, consulte [Creación de una definición de tareas de Amazon ECS mediante la consola](create-task-definition.md) y [Parámetros en la definición de tareas de Amazon ECS para Fargate](task_definition_parameters.md).

Para obtener más ejemplos de definición de tareas, consulte [Definiciones de tareas de muestra de AWS](https://github.com/aws-samples/aws-containers-task-definitions) en GitHub.

**Topics**
+ [

## Servidor web
](#example_task_definition-webserver)
+ [

## Controlador de registros de `splunk`
](#example_task_definition-splunk)
+ [

## Controlador de registros de `fluentd`
](#example_task_definition-fluentd)
+ [

## Controlador de registros de `gelf`
](#example_task_definition-gelf)
+ [

## Cargas de trabajo en instancias externas
](#ecs-anywhere-runtask)
+ [

## Rol de IAM de definición de tarea e imagen de Amazon ECR
](#example_task_definition-iam)
+ [

## Punto de entrada con comando
](#example_task_definition-ping)
+ [

## Dependencia de contenedor
](#example_task_definition-containerdependency)
+ [

## Volúmenes en definiciones de tareas
](#volume_sample_task_defs)
+ [

## Definiciones de tareas de muestra de Windows
](#windows_sample_task_defs)

## Servidor web
<a name="example_task_definition-webserver"></a>

A continuación, se muestra una definición de tarea de ejemplo con contenedores Linux en Fargate que configura un servidor 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" 
    ]
}
```

A continuación, se muestra una definición de tarea de ejemplo con contenedores Windows en Fargate que configura un servidor 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"]
}
```

## Controlador de registros de `splunk`
<a name="example_task_definition-splunk"></a>

En el fragmento siguiente se muestra cómo utilizar el controlador de registros `splunk` en una definición de tarea que envía los registros a un servicio remoto. El parámetro de token Splunk se especifica como una opción secreta, ya que puede tratarse como información confidencial. Para obtener más información, consulte [Transferencia de datos confidenciales a un contenedor de 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"
}],
```

## Controlador de registros de `fluentd`
<a name="example_task_definition-fluentd"></a>

En el fragmento siguiente se muestra cómo utilizar el controlador de registros `fluentd` en una definición de tarea que envía los registros a un servicio remoto. El valor `fluentd-address` se especifica como una opción secreta, ya que puede ser tratado como información confidencial. Para obtener más información, consulte [Transferencia de datos confidenciales a un contenedor de 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
	}]
}],
```

## Controlador de registros de `gelf`
<a name="example_task_definition-gelf"></a>

En el fragmento siguiente se muestra cómo utilizar el controlador de registros `gelf` en una definición de tarea que envía los registros a un host remoto que ejecuta Logstash que toma los registros de Gelf como entrada. Para obtener más información, consulte [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
		}
	]
}],
```

## Cargas de trabajo en instancias externas
<a name="ecs-anywhere-runtask"></a>

Cuando registre una definición de tareas de Amazon ECS, utilice el parámetro `requiresCompatibilities` y especifique `EXTERNAL` a fin de validar la compatibilidad de la definición de tareas para su utilización al ejecutar cargas de trabajo de Amazon ECS en las instancias externas. Si utiliza la consola para registrar una definición de tarea, debe utilizar el editor de JSON. Para obtener más información, consulte [Creación de una definición de tareas de Amazon ECS mediante la consola](create-task-definition.md).

**importante**  
Si las tareas requieren un rol de IAM de ejecución de tareas, asegúrese de que esté especificado en la definición de tareas. 

Cuando implemente la carga de trabajo, utilice el tipo de lanzamiento `EXTERNAL` al crear el servicio o ejecutar la tarea independiente.

A continuación, se muestra una definición de tareas de ejemplo.

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

------

## Rol de IAM de definición de tarea e imagen de Amazon ECR
<a name="example_task_definition-iam"></a>

El fragmento siguiente utiliza una imagen de Amazon ECR denominada `aws-nodejs-sample` con la etiqueta `v1` del registro `123456789012.dkr.ecr.us-west-2.amazonaws.com`. El contenedor de esta tarea hereda los permisos de IAM del rol `arn:aws:iam::123456789012:role/AmazonECSTaskS3BucketRole`. Para obtener más información, consulte [Rol de IAM de tarea de 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 de entrada con comando
<a name="example_task_definition-ping"></a>

El fragmento siguiente muestra la sintaxis de un contenedor de Docker que utiliza un punto de entrada y un argumento de comando. Este contenedor realiza ping a `example.com` cuatro veces y, a continuación, se cierra.

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

## Dependencia de contenedor
<a name="example_task_definition-containerdependency"></a>

Este fragmento muestra la sintaxis de una definición de tareas con varios contenedores donde se especifica la dependencia de contenedores. En la siguiente definición de tarea, el contenedor `envoy` debe llegar a un estado de funcionamiento correcto, determinado por los parámetros necesarios de comprobación de estado del contenedor, antes de que el contenedor `app` se inicie. Para obtener más información, consulte [Dependencia de contenedor](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"
}
```

## Volúmenes en definiciones de tareas
<a name="volume_sample_task_defs"></a>

Utilice lo siguiente para entender cómo especificar los volúmenes en las tareas.
+ Para obtener información acerca de cómo configurar un volumen de Amazon EBS, consulte [Especificación de la configuración del volumen de Amazon EBS durante la implementación de Amazon ECS](configure-ebs-volume.md).
+ Para obtener información acerca de cómo configurar un volumen de Amazon EFS, consulte [Configuración de sistemas de archivos de Amazon EFS para Amazon ECS mediante la consola](tutorial-efs-volumes.md).
+ Para obtener información acerca de cómo configurar un volumen de FSx for Windows File Server, consulte [Obtenga información sobre cómo configurar FSx para sistemas de archivos de Windows File Server para Amazon ECS.](tutorial-wfsx-volumes.md).
+ Para obtener información acerca de cómo configurar un volumen de Docker, consulte [Ejemplos de volúmenes de Docker para Amazon ECS](docker-volume-examples.md).
+ Para obtener información acerca de cómo configurar un montaje vinculado, consulte [Ejemplos de montajes vinculados para Amazon ECS](bind-mount-examples.md).

## Definiciones de tareas de muestra de Windows
<a name="windows_sample_task_defs"></a>

A continuación, se muestra una definición de tareas de muestra que lo ayudará a familiarizarse con los contenedores de Windows en Amazon ECS.

**Example Aplicación de muestra de consola de Amazon ECS para Windows**  
La siguiente definición de tareas corresponde a la aplicación de muestra de la consola de Amazon ECS que se observa en el asistente de primer uso de Amazon ECS; se ha transferido para que utilice la imagen de contenedor de 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"
}
```