Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Creación de un entorno de Docker administrado por ECS con la consola de Elastic Beanstalk

En este tutorial, se explica la configuración de contenedores y la preparación de código fuente para un entorno de Docker administrado por ECS que utiliza dos contenedores.

Los contenedores, una aplicación PHP y un proxy nginx, se ejecutan uno al lado del otro en cada una de las instancias de Amazon Elastic Compute Cloud (Amazon EC2) en un entorno de Elastic Beanstalk. Después de crear el entorno y comprobar que las aplicaciones están en ejecución, se conectará a una instancia de contenedor para ver cómo encaja todo.

Definir los contenedores de Docker administrados por ECS

El primer paso para crear un nuevo entorno de Docker es crear un directorio para los datos de la aplicación. Esta carpeta puede estar ubicada en cualquier lugar del equipo local y tener cualquier nombre. Además de un archivo de configuración del contenedor, esta carpeta incluirá el contenido que se carga en Elastic Beanstalk y se implementa en el entorno.

El archivo que Elastic Beanstalk utiliza para configurar los contenedores en una instancia de Amazon EC2 es un archivo de texto con formato JSON denominado Dockerrun.aws.json v2. Las versiones de la plataforma Docker administrada por ECS utilizan el formato de la versión 2 de este archivo. Este formato solo se puede usar con la plataforma Docker administrada por ECS, ya que difiere considerablemente de las demás versiones del archivo de configuración que admiten las ramas de la plataforma Docker que no están administradas por ECS.

Cree un archivo de texto Dockerrun.aws.json v2 con este nombre en la raíz de la aplicación y agregue el siguiente texto:

{
  "AWSEBDockerrunVersion": 2,
  "volumes": [
    {
      "name": "php-app",
      "host": {
        "sourcePath": "/var/app/current/php-app"
      }
    },
    {
      "name": "nginx-proxy-conf",
      "host": {
        "sourcePath": "/var/app/current/proxy/conf.d"
      }
    }  
  ],
  "containerDefinitions": [
    {
      "name": "php-app",
      "image": "php:fpm",
      "essential": true,
      "memory": 128,
      "mountPoints": [
        {
          "sourceVolume": "php-app",
          "containerPath": "/var/www/html",
          "readOnly": true
        }
      ]
    },
    {
      "name": "nginx-proxy",
      "image": "nginx",
      "essential": true,
      "memory": 128,
      "portMappings": [
        {
          "hostPort": 80,
          "containerPort": 80
        }
      ],
      "links": [
        "php-app"
      ],
      "mountPoints": [
        {
          "sourceVolume": "php-app",
          "containerPath": "/var/www/html",
          "readOnly": true
        },
        {
          "sourceVolume": "nginx-proxy-conf",
          "containerPath": "/etc/nginx/conf.d",
          "readOnly": true
        },
        {
          "sourceVolume": "awseb-logs-nginx-proxy",
          "containerPath": "/var/log/nginx"
        }
      ]
    }
  ]
}

Esta configuración de ejemplo define dos contenedores y un sitio web de PHP con un proxy nginx delante. Estos dos contenedores se ejecutarán en paralelo en los contenedores de Docker de cada instancia del entorno de Elastic Beanstalk y obtendrán acceso al contenido compartido (el contenido del sitio web) desde los volúmenes de la instancia del host, que también se define en este archivo. Los propios contenedores se crean a partir de imágenes hospedadas en repositorios oficiales de Docker Hub. El entorno resultante se parece al siguiente:

Los volúmenes definidos en la configuración corresponden al contenido que va a crear a continuación y a cargar como parte del paquete de código fuente de la aplicación. Los contenedores obtienen acceso al contenido del host montando volúmenes en la sección mountPoints de las definiciones de contenedor.

Para obtener más información sobre el formato de Dockerrun.aws.json v2 y sus parámetros, consulte Formato de definición de contenedor.

Agregar contenido

A continuación, va a agregar contenido en el sitio de PHP para que lo vean los visitantes y un archivo de configuración para el proxy nginx.

php-app/index.php

<h1>Hello World!!!</h1>
<h3>PHP Version <pre><?= phpversion()?></pre></h3>

php-app/static.html

<h1>Hello World!</h1>
<h3>This is a static HTML page.</h3>

proxy/conf.d/default.conf

server {
  listen 80;
  server_name localhost;
  root /var/www/html;
 
  index index.php;
 
  location ~ [^/]\.php(/|$) {
    fastcgi_split_path_info ^(.+?\.php)(/.*)$;
    if (!-f $document_root$fastcgi_script_name) {
      return 404;
    }

    include fastcgi_params;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    fastcgi_param PATH_INFO $fastcgi_path_info;
    fastcgi_param PATH_TRANSLATED $document_root$fastcgi_path_info;

    fastcgi_pass php-app:9000;
    fastcgi_index index.php;
  }
}

Implementar en Elastic Beanstalk

Ahora, la carpeta de la aplicación contiene los siguientes archivos:

├── Dockerrun.aws.json
├── php-app
│   ├── index.php
│   └── static.html
└── proxy
    └── conf.d
        └── default.conf

Esto es todo lo que necesita para crear el entorno Elastic Beanstalk. Cree un archivo .zip con los documentos y carpetas anteriores (no incluya la carpeta del proyecto del nivel superior). Para crear el archivo en el Explorador de Windows, seleccione el contenido de la carpeta del proyecto, haga clic con el botón derecho, seleccione Enviar a y haga clic en Carpeta comprimida (en zip).

A continuación, cargue el paquete de origen en Elastic Beanstalk y cree su entorno. En Platform (Plataforma), seleccione Docker. Para la Ramificación de la plataforma, seleccione ECS que se ejecuta en Amazon Linux 2023 de 64 bits.

La consola de Elastic Beanstalk le redirigirá al panel de administración del nuevo entorno. En esta pantalla, se muestra el estado del entorno y la salida de eventos del servicio Elastic Beanstalk. Si el estado es verde, haga clic en la URL que está situada junto al nombre del entorno para ver el nuevo sitio web.

Conexión con una instancia de contenedor

A continuación, va a conectarse a una instancia de Amazon EC2 del entorno de Elastic Beanstalk para ver algunos de sus componentes en acción.

La forma más sencilla de conectarse a una instancia del entorno es utilizar la CLI de EB. Para utilizarla, instale la CLI de EB, si aún no lo ha hecho. También necesitará configurar su entorno con un par de claves SSH de Amazon EC2. Para ello, utilice la página de configuración de seguridad de la consola o el comando eb init de la CLI de EB. Para conectarse a una instancia del entorno, utilice el comando eb ssh de la CLI de EB.

Ahora que se ha conectado a la instancia Amazon EC2 que hospeda los contenedores de Docker, puede ver cómo funciona todo. Ejecute ls en /var/app/current:

[ec2-user@ip-10-0-0-117 ~]$ ls /var/app/current
Dockerrun.aws.json  php-app  proxy

Este directorio contiene los archivos del paquete de código fuente que cargó en Elastic Beanstalk durante la creación del entorno.

[ec2-user@ip-10-0-0-117 ~]$ ls /var/log/containers
nginx-proxy    nginx-proxy-4ba868dbb7f3-stdouterr.log     
php-app        php-app-dcc3b3c8522c-stdouterr.log       rotated

Aquí es donde se crean los logs de la instancia de contenedor y los recopila Elastic Beanstalk. Elastic Beanstalk crea un volumen en este directorio para cada contenedor, que se monta en la ubicación del contenedor donde se escriben los logs.

También puede consultar Docker para ver los contenedores en ejecución mediante docker ps.

[ec2-user@ip-10-0-0-117 ~]$ sudo docker ps
CONTAINER ID   IMAGE                            COMMAND                  CREATED         STATUS                  PORTS                               NAMES                                                
4ba868dbb7f3   nginx                            "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes            0.0.0.0:80->80/tcp, :::80->80/tcp   ecs-awseb-Tutorials-env-dc2aywfjwg-1-nginx-proxy-acca84ef87c4aca15400        
dcc3b3c8522c   php:fpm                          "docker-php-entrypoi…"   4 minutes ago   Up 4 minutes            9000/tcp                            ecs-awseb-Tutorials-env-dc2aywfjwg-1-php-app-b8d38ae288b7b09e8101                             
d9367c0baad6   amazon/amazon-ecs-agent:latest   "/agent"                 5 minutes ago   Up 5 minutes (healthy)                                      ecs-agent

Aquí pueden verse los dos contenedores en ejecución que implementó, así como el agente de contenedor de Amazon ECS que coordinó la implementación.

Inspeccione el agente de contenedor de Amazon ECS

Las instancias de Amazon EC2 de un entorno de Docker administrado por ECS de Elastic Beanstalk ejecutan un proceso del agente en un contenedor de Docker. Este agente se conecta con el servicio Amazon ECS; para coordinar las implementaciones de contenedores. Estas implementaciones se ejecutan como tareas de Amazon ECS, que están configuradas en los archivos de definición de tareas. Elastic Beanstalk crea estos archivos de definición de tareas en función del archivo Dockerrun.aws.json que se carga en el paquete de código fuente.

Compruebe el estado del agente de contenedor con una solicitud HTTP GET en http://localhost:51678/v1/metadata:

[ec2-user@ip-10-0-0-117 ~]$ curl http://localhost:51678/v1/metadata
{
  "Cluster":"awseb-Tutorials-env-dc2aywfjwg",
  "ContainerInstanceArn":"arn:aws:ecs:us-west-2:123456789012:container-instance/awseb-Tutorials-env-dc2aywfjwg/db7be5215cd74658aacfcb292a6b944f",
  "Version":"Amazon ECS Agent - v1.57.1 (089b7b64)"
}

Esta estructura muestra el nombre del clúster de Amazon ECS y el ARN (nombre de recurso de Amazon) de la instancia del clúster (instancia de Amazon EC2 a la que está conectado).

Para obtener más información, realice una solicitud HTTP GET en http://localhost:51678/v1/tasks:

[ec2-user@ip-10-0-0-117 ~]$ curl http://localhost:51678/v1/tasks
{
   "Tasks":[
      {
         "Arn":"arn:aws:ecs:us-west-2:123456789012:task/awseb-Tutorials-env-dc2aywfjwg/bbde7ebe1d4e4537ab1336340150a6d6",
         "DesiredStatus":"RUNNING",
         "KnownStatus":"RUNNING",
         "Family":"awseb-Tutorials-env-dc2aywfjwg",
         "Version":"1",
         "Containers":[
            {
               "DockerId":"dcc3b3c8522cb9510b7359689163814c0f1453b36b237204a3fd7a0b445d2ea6",
               "DockerName":"ecs-awseb-Tutorials-env-dc2aywfjwg-1-php-app-b8d38ae288b7b09e8101",
               "Name":"php-app",
               "Volumes":[
                  {
                     "Source":"/var/app/current/php-app",
                     "Destination":"/var/www/html"
                  }
               ]
            },
            {
               "DockerId":"4ba868dbb7f3fb3328b8afeb2cb6cf03e3cb1cdd5b109e470f767d50b2c3e303",
               "DockerName":"ecs-awseb-Tutorials-env-dc2aywfjwg-1-nginx-proxy-acca84ef87c4aca15400",
               "Name":"nginx-proxy",
               "Ports":[
                  {
                     "ContainerPort":80,
                     "Protocol":"tcp",
                     "HostPort":80
                  },
                  {
                     "ContainerPort":80,
                     "Protocol":"tcp",
                     "HostPort":80
                  }
               ],
               "Volumes":[
                  {
                     "Source":"/var/app/current/php-app",
                     "Destination":"/var/www/html"
                  },
                  {
                     "Source":"/var/log/containers/nginx-proxy",
                     "Destination":"/var/log/nginx"
                  },
                  {
                     "Source":"/var/app/current/proxy/conf.d",
                     "Destination":"/etc/nginx/conf.d"
                  }
               ]
            }
         ]
      }
   ]
}

Esta estructura describe la tarea que se ejecuta para implementar los dos contenedores en el proyecto de ejemplo de este tutorial. Se muestra la siguiente información:

Hay aún más información disponible en el mismo servicio Amazon ECS, que puede llamar con la AWS Command Line Interface. Para obtener instrucciones sobre el uso de la AWS CLI con Amazon ECS e información sobre Amazon ECS en general, consulte la Guía del usuario de Amazon ECS.