Creación de una tarea de Linux de Amazon ECS para el tipo de lanzamiento de Fargate con la AWS CLI - Amazon Elastic Container Service
Requisitos previosPaso 1: Crear un clústerPaso 2: Registrar una definición de tarea LinuxPaso 3: Mostrar la lista de definiciones de tareasPaso 4: Crear un servicioPaso 5: Mostrar la lista de los serviciosPaso 6: Describir el servicio en ejecuciónPaso 7: PruebaPaso 8: Eliminación

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

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.

Requisitos previos

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.

  • Se han completado los pasos que se indican en Configuración para utilizar Amazon ECS.

  • Su usuario de AWS dispone de los permisos requeridos que se especifican en la política de IAM 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.

    Para obtener información sobre las reglas y los grupos de seguridad, consulte Default security groups for your VPCs (Grupos de seguridad predeterminados para sus VPC) y Example rules (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.

  • (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.

Paso 1: Crear un clúster

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

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

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

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

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

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

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. Para obtener más información acerca de la descripción del servicio, consulte Describir servicios.

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

Prueba de tarea implementada mediante una subred pública

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

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

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

Eliminar el clúster.

aws ecs delete-cluster --cluster fargate-cluster