Definir los contenedores de Docker administrados por ECS Agregar contenido Implementar en Elastic Beanstalk Conexión con una instancia de contenedor Inspeccione el agente de contenedor de Amazon ECS

Entornos de Docker administrados por ECS con la consola de Elastic Beanstalk

Puede lanzar un clúster de instancias de varios contenedores en un entorno de Elastic Beanstalk de instancia única o escalable mediante 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 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.

Secciones

Definir los contenedores de Docker administrados por ECS
Agregar contenido
Implementar en Elastic Beanstalk
Conexión con una instancia de contenedor
Inspeccione el agente de contenedor de Amazon ECS

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.

nota

Todo el código de este tutorial está disponible en el repositorio awslabs de GitHub, en https://github.com/awslabs/eb-docker-nginx-proxy.

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. Cree un archivo de texto 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 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).

nota

Para obtener más información sobre la estructura de archivos e instrucciones para la creación de archivos en otros entornos, consulte Cree el paquete de código fuente de la aplicación.

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

Para lanzar un entorno (consola)

Abra la consola de Elastic Beanstalk con este enlace preconfigurado: console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced
En Platform (Plataforma), seleccione la plataforma y la ramificación de plataforma que coincidan con el idioma utilizado por su aplicación, o la plataforma Docker para aplicaciones basadas en contenedores.
En Application code (Código de aplicación), seleccione Upload your code (Cargar su propio código).
Elija Local file (Archivo local), seleccione Choose file (Seleccionar archivo) y abra el paquete de código fuente.
Elija Review and launch (Revisar y lanzar).
Revise la configuración disponible y, a continuación, elija Create app (Crear aplicación).

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:

KnownStatus: el estado RUNNING indica que los contenedores siguen activos.
Family (Familia): nombre de la definición de tarea a partir de la que Elastic Beanstalk creó Dockerrun.aws.json.
Version: versión de la definición de tareas. Esta aumenta cada vez que el archivo de definición de tareas se actualiza.
Containers: información sobre los contenedores que se ejecutan en la instancia.

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.

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

Configuración de Docker administrado por ECS

Migración a ECS sobre AL2023