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 en paralelo en cada una de las instancias de Amazon Elastic Compute Cloud ( EC2Amazon) 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.
**Topics**
+ [Definir los contenedores de Docker administrados por ECS](#create_deploy_docker_ecstutorial_config)
+ [Agregar contenido](#create_deploy_docker_ecstutorial_code)
+ [Implementar en Elastic Beanstalk](#create_deploy_docker_ecstutorial_deploy)
+ [Conexión con una instancia de contenedor](#create_deploy_docker_ecstutorial_connect)
+ [Inspeccione el agente de contenedor de Amazon ECS](#create_deploy_docker_ecstutorial_connect_inspect)
## 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 en. GitHub [https://github.com/awslabs/eb-docker-nginx-proxy](https://github.com/awslabs/eb-docker-nginx-proxy)
El archivo que Elastic Beanstalk utiliza para configurar los contenedores en una instancia de EC2 Amazon es un archivo de texto con formato JSON denominado v2. `Dockerrun.aws.json` 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:
![\[Elastic Beanstalk environment with load balancer, auto scaling group, and two instances running Nginx and PHP-FPM.\]](http://docs.aws.amazon.com/es_es/elasticbeanstalk/latest/dg/images/aeb-multicontainer-tutorial.png)
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](create_deploy_docker_v2config.md#create_deploy_docker_v2config_dockerrun_format).
## 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**
```
Hello World!!!
PHP Version
```
**php-app/static.html**
```
Hello World!
This is a static HTML page.
```
**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 [Creación de una agrupación de orígenes de aplicación en Elastic Beanstalk.](applications-sourcebundle.md)
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**.
**Para lanzar un entorno (consola)**
1. [Abra la consola de Elastic Beanstalk con este enlace preconfigurado: console.aws.amazon. com/elasticbeanstalk/home\$1/newApplication? ApplicationName=Tutorials&EnvironmentType= LoadBalanced](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced)
1. 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.
1. En **Código de la aplicación**, seleccione **Cargar su propio código**.
1. Elija **Local file (Archivo local)**, seleccione **Choose file (Seleccionar archivo)** y abra el paquete de código fuente.
1. Elija **Review and launch (Revisar y lanzar)**.
1. Revise la configuración disponible y, a continuación, elija **Create app (Creación de 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, se conectará a una EC2 instancia de Amazon en su entorno de Elastic Beanstalk para ver algunas de las partes móviles 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](eb-cli3.md#eb-cli3-install), si aún no lo ha hecho. También tendrá que configurar el entorno con un par de claves Amazon EC2 SSH. Para ello, utilice la [página de configuración de seguridad](using-features.managing.security.md) de la consola o el comando [eb init](eb3-init.md) de la CLI de EB. Para conectarse a una instancia del entorno, utilice el comando [eb ssh](eb3-ssh.md) de la CLI de EB.
Ahora que estás conectado a una EC2 instancia de Amazon que aloja tus contenedores de docker, puedes ver cómo están configuradas las cosas. 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
EC2 Las instancias de Amazon en un entorno Docker gestionado por ECS en Elastic Beanstalk ejecutan un proceso de 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](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)) de la instancia del clúster (la 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 `RUNNING` estado 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 AWS CLI de Amazon ECS e información sobre Amazon ECS en general, consulte la [Guía del usuario de Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_GetStarted.html).