# Creación de una tarea de Linux de Amazon ECS para Fargate con AWS CLI
<a name="ECS_AWSCLI_Fargate"></a>

Los siguientes pasos le ayudan a configurar un clúster, registrar una definición de tarea, ejecutar una tarea Linux y llevar a cabo otros escenarios comunes en Amazon ECS con la AWS CLI. Utilice la versión más reciente de la AWS CLI. Para obtener más información acerca de cómo actualizar a la versión más reciente, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**nota**  
Puede utilizar puntos de conexión de servicio de doble pila para interactuar con Amazon ECS desde la AWS CLI, los SDK y la API de Amazon ECS a través de IPv4 e IPv6. Para obtener más información, consulte [Uso de puntos de conexión de doble pila en Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [Requisitos previos](#ECS_AWSCLI_Fargate_prereq)
+ [Paso 1: Crear un clúster](#ECS_AWSCLI_Fargate_create_cluster)
+ [Paso 2: Registrar una definición de tarea Linux](#ECS_AWSCLI_Fargate_register_task_definition)
+ [Paso 3: Mostrar la lista de definiciones de tareas](#ECS_AWSCLI_Fargate_list_task_definitions)
+ [Paso 4: Crear un servicio](#ECS_AWSCLI_Fargate_create_service)
+ [Paso 5: Mostrar la lista de los servicios](#ECS_AWSCLI_Fargate_list_services)
+ [Paso 6: Describir el servicio en ejecución](#ECS_AWSCLI_Fargate_describe_service)
+ [Paso 7: Prueba](#ECS_AWSCLI_Fargate_test)
+ [Paso 8: eliminación](#ECS_AWSCLI_Fargate_clean_up)

## Requisitos previos
<a name="ECS_AWSCLI_Fargate_prereq"></a>

En este tutorial se supone que los siguientes requisitos previos se han realizado.
+ La última versión de la AWS CLI está instalada y configurada. Para obtener información acerca de cómo instalar o actualizar la AWS CLI, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Se han completado los pasos que se indican en [Configuración para utilizar Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Su usuario de IAM dispone de los permisos requeridos que se especifican en la política de IAM [AmazonECS\$1FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) de ejemplo.
+ Tiene una VPC y un grupo de seguridad creados para utilizarlos. En este tutorial se utiliza una imagen de contenedor alojada en Amazon ECR Public por lo que su tarea debe tener acceso a Internet. Para que su tarea tenga una ruta a Internet, utilice una de las siguientes opciones.
  + Utilice una subred privada con una gateway NAT que tenga una dirección IP elástica.
  + Utilice una subred pública y asigne una dirección IP pública a la tarea.

  Para obtener más información, consulte [Creación de una nube virtual privada](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Para obtener información sobre las reglas y los grupos de seguridad, consulte [Default security groups for your VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) (Grupos de seguridad predeterminados para sus VPC) y [Example rules](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) (Reglas de ejemplo) en la *Guía del usuario de Amazon Virtual Private Cloud*.
+  Si sigue este tutorial utilizando una subred privada, puede utilizar Amazon ECS Exec para interactuar directamente con el contenedor y probar la implementación. Necesitará crear un rol de IAM en una tarea para usar ECS Exec. Para obtener más información acerca del rol de IAM de la tarea y otros requisitos previos, consulte [Supervisión de los contenedores de Amazon ECS con Amazon ECS Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html).
+ (Opcional) AWS CloudShell es una herramienta que proporciona a los clientes una línea de comandos sin necesidad de crear su propia instancia de EC2. Para obtener más información, consulte [¿Qué es AWS CloudShell?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) en la *Guía del usuario de AWS CloudShell*.

## Paso 1: Crear un clúster
<a name="ECS_AWSCLI_Fargate_create_cluster"></a>

De forma predeterminada, la cuenta recibe un clúster `default`.

**nota**  
El beneficio de utilizar el clúster `default` que se le facilita es que no tiene que especificar la opción `--cluster cluster_name` en los comandos siguientes. Si crea su propio clúster no predeterminado, tiene que especificar `--cluster cluster_name` para cada comando que pretenda utilizar con dicho clúster.

Cree su propio clúster con un nombre único con el comando siguiente:

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Salida:

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

## Paso 2: Registrar una definición de tarea Linux
<a name="ECS_AWSCLI_Fargate_register_task_definition"></a>

Antes de poder ejecutar una tarea en su clúster de ECS, debe registrar una definición de tareas. Las definiciones de tareas son listas de contenedores agrupadas. El siguiente ejemplo es una definición de tarea simple que crea una aplicación web PHP usando la imagen del contenedor httpd alojada en Docker Hub. Para obtener más información acerca de los parámetros de definición de tareas disponibles, consulte [Definiciones de tareas de Amazon ECS](task_definitions.md). Para este tutorial, el `taskRoleArn` solo es necesario si va a implementar la tarea en una subred privada y desea probar la implementación. Reemplace el `taskRoleArn` por el rol de tarea de IAM que creó para utilizar ECS Exec, como se menciona en [Requisitos previos](#ECS_AWSCLI_Fargate_prereq).

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

Guarde el JSON de definición de tarea como un archivo y páselo con la opción `--cli-input-json file://path_to_file.json`. 

Para utilizar un archivo JSON para definiciones de contenedor:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

El comando **register-task-definition** devuelve una descripción de la definición de tarea después de realizar su registro.

## Paso 3: Mostrar la lista de definiciones de tareas
<a name="ECS_AWSCLI_Fargate_list_task_definitions"></a>

Puede enumerar las definiciones de tareas para su cuenta en cualquier momento con el comando **list-task-definitions**. La salida de este comando muestra los valores `family` y `revision`, que puede utilizar conjuntamente al llamar a **run-task** o **start-task**.

```
aws ecs list-task-definitions
```

Salida:

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
    ]
}
```

## Paso 4: Crear un servicio
<a name="ECS_AWSCLI_Fargate_create_service"></a>

Una vez que se haya registrado una tarea para la cuenta, puede crear un servicio para la tarea registradas en su clúster. En este ejemplo, se crea un servicio con una instancia de la definición de tarea `sample-fargate:1` que se ejecuta en el clúster. La tarea requiere una ruta a Internet, por lo que hay dos maneras de lograr esto. Una forma es utilizar una subred privada configurada con una gateway NAT con una dirección IP elástica en una subred pública. Otra forma es utilizar una subred pública y asignar una dirección IP pública a su tarea. A continuación, ofrecemos ambos ejemplos. 

Ejemplo de uso de una subred privada. La opción ` enable-execute-command ` es necesaria para utilizar Amazon ECS Exec.

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

Ejemplo de uso de una subred pública.

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

El comando **create-service** devuelve una descripción de la definición de tarea después de realizar su registro.

## Paso 5: Mostrar la lista de los servicios
<a name="ECS_AWSCLI_Fargate_list_services"></a>

Enumere los servicios de su clúster. Debe aparecer el servicio que ha creado en la sección anterior. Puede tomar el nombre de servicio o el ARN completo que se devuelve desde este comando y utilizarlo para describir el servicio más adelante.

```
aws ecs list-services --cluster fargate-cluster
```

Salida:

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-cluster/fargate-service"
    ]
}
```

## Paso 6: Describir el servicio en ejecución
<a name="ECS_AWSCLI_Fargate_describe_service"></a>

Describa el servicio utilizado el nombre del servicio recuperado antes para obtener información adicional sobre la tarea.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

Si tiene éxito, devolverá una descripción de los errores del servicio y los servicios. Por ejemplo, en la sección ` services `, encontrará información sobre implementaciones, como el estado de las tareas en ejecución o pendientes. También puede encontrar información sobre la definición de tarea, la configuración de la red y los eventos con marca temporal. En la sección de errores, encontrará información sobre los errores, si los hay, asociados a la llamada. Para solucionar problemas, consulte [Mensajes de eventos de servicio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Para obtener más información acerca de la descripción del servicio, consulte [Describir servicios](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": []
}
```

## Paso 7: Prueba
<a name="ECS_AWSCLI_Fargate_test"></a>

### Prueba de tarea implementada mediante una subred pública
<a name="ECS_AWSCLI_Fargate_test_public"></a>

Describa la tarea del servicio para que pueda obtener la interfaz de red elástica (ENI) para la tarea. 

Primero, obtenga el ARN de la tarea.

```
aws ecs list-tasks --cluster fargate-cluster --service fargate-service
```

El resultado contiene el ARN de la tarea.

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
    ]
}
```

Describa la tarea y busque el ID de ENI. Utilice el ARN de tareas para el parámetro `tasks`.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/service/EXAMPLE
```

La información de datos adjuntos se muestra en la salida. 

```
{
    "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                    ]
                }
…
}
```

Describa el ENI para obtener la dirección IP pública.

```
aws ec2 describe-network-interfaces --network-interface-id  eni-0fa40520aeEXAMPLE
```

La dirección IP pública se encuentra en la salida. 

```
{
    "NetworkInterfaces": [
        {
            "Association": {
                "IpOwnerId": "amazon",
                "PublicDnsName": "ec2-34-229-42-222.compute-1.amazonaws.com",
                "PublicIp": "198.51.100.2"
            },
…
}
```

Ingrese dicha dirección IP pública en el navegador web. Debe ver una página web en la que se muestre la aplicación **Amazon ECS **de muestra.

### Prueba de tarea implementada mediante una subred privada
<a name="ECS_AWSCLI_Fargate_test_private.title"></a>

 Describa la tarea y ubique los `managedAgents` para comprobar que el `ExecuteCommandAgent` se está ejecutando. Tenga en cuenta la `privateIPv4Address` para un uso posterior.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
```

 La información administrada del agente se enumera en la salida. 

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

 Después de comprobar que el ` ExecuteCommandAgent` se está ejecutando, puede ejecutar el siguiente comando para ejecutar un intérprete de comandos interactivo en el contenedor de la tarea. 

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

 Después de ejecutar el intérprete de comandos interactivo, ejecute los siguientes comandos para instalar la cURL. 

```
apt update 
```

```
apt install curl 
```

 Tras instalar la cURL, ejecute el siguiente comando con la dirección IP privada que obtuvo anteriormente.

```
 curl 10.0.143.156 
```

 Debería ver el equivalente en HTML de la página web de la aplicación de ejemplo de **Amazon ECS**.

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

## Paso 8: eliminación
<a name="ECS_AWSCLI_Fargate_clean_up"></a>

Cuando termine este tutorial, debe limpiar los recursos asociados para evitar incurrir en cargos generados por recursos sin utilizar.

Elimine el servicio.

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Elimine el clúster.

```
aws ecs delete-cluster --cluster fargate-cluster
```