Requisitos previos Creación de un clúster Lanzamiento de una instancia de contenedor de AMI para Amazon ECS Enumeración de instancias de contenedor Descripción de la instancia de contenedor Registro de una definición de tareas Enumeración de definiciones de tareas Crear un servicio Enumeración de servicios Descripción de los servicios Descripción de la tarea en ejecución Prueba del servidor web Eliminar recursos

Creación de una tarea de Amazon ECS para el tipo de lanzamiento de EC2 con la AWS CLI

Los siguientes pasos le ayudan a configurar un clúster, registrar una definición de tarea, ejecutar una tarea 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.

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.

Temas

Requisitos previos
Creación de un clúster
Lanzamiento de una instancia de contenedor de AMI para Amazon ECS
Enumeración de instancias de contenedor
Descripción de la instancia de contenedor
Registro de una definición de tareas
Enumeración de definiciones de tareas
Crear un servicio
Enumeración de servicios
Descripción de los servicios
Descripción de la tarea en ejecución
Prueba del servidor web
Eliminar recursos

Requisitos previos

En este tutorial se supone que los siguientes requisitos previos se han completado:

La última versión de la AWS CLI está instalada y configurada. Para obtener más información acerca de cómo instalar la AWS CLI o actualizarla, consulte Instalación o actualización de la versión más reciente de la AWS CLI.
Se han completado los pasos que se indican en Configuración para utilizar Amazon ECS.
Su usuario de IAM dispone de los permisos requeridos que se especifican en la política de IAM AmazonECS_FullAccess de ejemplo.
Se ha creado un rol de IAM de instancia de contenedor para usarlo. Para obtener más información, consulte Rol de IAM de instancia de contenedor de Amazon ECS.
Se ha creado una VPC para usarla. Para obtener más información, consulte Creación de una nube virtual privada.
(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? en la Guía del usuario de AWS CloudShell.

Creación de un clúster

De forma predeterminada, su cuenta recibe un clúster default donde lanzar su primera instancia de contenedor.

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 MyCluster

Salida:


{
    "cluster": {
        "clusterName": "MyCluster",
        "status": "ACTIVE",
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/MyCluster"
    }
}

Lanzamiento de una instancia de contenedor de AMI para Amazon ECS

Las instancias de contenedor son instancias de EC2 que ejecutan el agente de contenedor de Amazon ECS y que se han registrado en un clúster. En esta sección, lanzará una instancia EC2 con la AMI optimizada para ECS.

Lanzamiento de una instancia de contenedor con la AWS CLI

Recupere el último ID de AMI de Amazon Linux 2 optimizado para ECS para su Región de AWS mediante el siguiente comando. Este comando utiliza el almacén de parámetros AWS Systems Manager para obtener el último ID de AMI optimizado para ECS. La AMI incluye el agente de contenedor de Amazon ECS y el tiempo de ejecución de Docker preinstalados.
```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/recommended --query 'Parameters[0].Value' --output text | jq -r '.image_id'
```
Salida:
```
ami-abcd1234
```
Cree un grupo de seguridad que permita el acceso SSH para administrar la instancia de contenedor y el acceso HTTP para el servidor web.
```
aws ec2 create-security-group --group-name ecs-tutorial-sg --description "ECS tutorial security group"
```
Salida:
```
{
    "GroupId": "sg-abcd1234"
}
```

Agregue una regla de entrada al grupo de seguridad mediante la ejecución del siguiente comando.


aws ec2 authorize-security-group-ingress --group-id sg-abcd1234 --protocol tcp --port 80 --cidr 0.0.0.0/0

Salida:


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

El grupo de seguridad ahora permite el acceso SSH desde el rango de IP especificado y el acceso HTTP desde cualquier lugar. En un entorno de producción, debe restringir el acceso SSH a su dirección IP específica y plantearse la limitación del acceso HTTP según sea necesario.

Cree un par de claves EC2 para el acceso SSH a su instancia de contenedor.
```
aws ec2 create-key-pair --key-name ecs-tutorial-key --query 'KeyMaterial' --output text > ecs-tutorial-key.pem
chmod 400 ecs-tutorial-key.pem
```
La clave privada se guarda en la máquina local con los permisos adecuados para el acceso SSH.

Lance una instancia EC2 mediante la AMI optimizada para ECS y configúrela para que se una a su clúster.


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

El script de datos de usuario configura el agente de Amazon ECS para que registre la instancia en su MyCluster. La instancia usa el rol de IAM ecsInstanceRole, que proporciona los permisos necesarios para el agente.

Enumeración de instancias de contenedor

A los pocos minutos de lanzar la instancia de contenedor, el agente de Amazon ECS registra la instancia con su clúster predeterminado. Puede mostrar la lista de las instancias de contenedor de un clúster ejecutando el comando siguiente:


aws ecs list-container-instances --cluster default

Salida:


{
    "containerInstanceArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:container-instance/container_instance_ID"
    ]
}

Descripción de la instancia de contenedor

Una vez que tenga el ARN o el ID de una instancia de contenedor, puede utilizar el comando describe-container-instances para obtener información valiosa sobre la instancia, como por ejemplo, los recursos registrados y restantes de CPU y de memoria.


aws ecs describe-container-instances --cluster MyCluster --container-instances container_instance_ID

Salida:


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

También puede buscar el ID de instancia de Amazon EC2 que puede utilizar para monitorizar la instancia en la consola de Amazon EC2 o con el comando aws ec2 describe-instances --instance-id instance_id.

Registro de una definición de tareas

Antes de poder ejecutar una tarea en su clúster de Amazon ECS, debe registrar una definición de tareas. Las definiciones de tareas son listas de contenedores agrupadas. El ejemplo siguiente es una definición de tareas sencilla que utiliza una imagen nginx. Para obtener más información acerca de los parámetros de definición de tareas disponibles, consulte Definiciones de tareas de Amazon ECS.


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

El ejemplo anterior de JSON se puede transferir a la AWS CLI de dos formas: puede guardar la definición de tareas JSON como un archivo y transferirlo con la opción --cli-input-json file://path_to_file.json. O bien, puede eludir las comillas en JSON y transferir las definiciones de contenedor JSON en la línea de comandos. Si elige transferir las definiciones de contenedor en la línea de comandos, el comando requiere adicionalmente un parámetro --family que se utiliza para mantener varias versiones de la definición de tareas asociadas entre sí.

Para utilizar un archivo JSON para definiciones de contenedor:


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

register-task-definition devuelve una descripción de la definición de tarea después de completar su registro.


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

Enumeración de definiciones de tareas

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 se pueden utilizar conjuntamente al llamar a create-service.


aws ecs list-task-definitions

Salida:


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

Crear un servicio

Después de haber registrado una tarea para la cuenta y haber lanzado una instancia de contenedor que esté registrada en su clúster, puede crear un servicio de Amazon ECS que ejecute y mantenga el número deseado de tareas simultáneamente mediante la definición de tarea que se haya registrado. Para este ejemplo, coloque una instancia única de la definición de tarea nginx:1 en su clúster predeterminado.


aws ecs create-service --cluster default --service-name nginx-service --task-definition nginx-task:1 --desired-count 1

Salida:


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

Enumeración de servicios

Enumere los servicios de su clúster. Debe aparecer el servicio que ha creado en la sección anterior. Puede tomar nota del ID 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 MyCluster

Salida:


{
    "taskArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:task/task_ID"
    ]
}

Descripción de los servicios

Describa el servicio con el siguiente comando para obtener más información sobre el servicio.


aws ecs describe-services --cluster MyCluster --services nginx-service

Salida:


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

Descripción de la tarea en ejecución

Después de describir el servicio, ejecute el siguiente comando para obtener más información sobre la tarea que se está ejecutando como parte de su servicio.


aws ecs list-tasks --cluster MyCluster --service-name nginx-service

Salida:


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

Prueba del servidor web

Obtenga la dirección IP pública de su instancia de contenedor con la ejecución del siguiente comando.


aws ec2 describe-instances --instance-ids i-abcd1234 --query 'Reservations[0].Instances[0].PublicIpAddress' --output text

Salida:


203.0.113.25

Después de recuperar la dirección IP, ejecute el siguiente comando curl con la dirección IP.


curl http://203.0.113.25

Salida:


<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
...
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you can see this page, the nginx web server is successfully installed and working.</p>
...
</body>
</html>

La página de bienvenida de nginx confirma que el servicio se está ejecutando correctamente y que es accesible desde Internet.

Eliminar recursos

Para dejar de incurrir en cargos, debe limpiar los recursos que se crearon en este tutorial.

Cómo limpiar los recursos

Actualice el servicio para que no tener tarea deseadas y, a continuación, elimínelo.


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

Espere a que se detengan las tareas en ejecución y, a continuación, elimine el servicio.


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

Finalice la instancia de contenedor que creó.


aws ec2 terminate-instances --instance-ids i-abcd1234
{
    "TerminatingInstances": [
        {
            "InstanceId": "i-abcd1234",
            "CurrentState": {
                "Code": 32,
                "Name": "shutting-down"
            },
            "PreviousState": {
                "Code": 16,
                "Name": "running"
            }
        }
    ]
}

Limpie el grupo de seguridad y el par de claves que creó.


aws ec2 delete-security-group --group-id sg-abcd1234
aws ec2 delete-key-pair --key-name ecs-tutorial-key
rm ecs-tutorial-key.pem

Elimine el clúster de Amazon ECS.


aws ecs delete-cluster --cluster MyCluster
{
    "cluster": {
        "clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
        "clusterName": "MyCluster",
        "status": "INACTIVE"
    }
}

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Creación de una tarea de Windows para el tipo de lanzamiento de Fargate con la AWS CLI

Configuración de Amazon ECS para escuchar los eventos de Eventos de CloudWatch