

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.

# Preparación de la imagen de Docker para implementarla en Elastic Beanstalk
<a name="single-container-docker-configuration"></a>

En esta sección se describe cómo preparar la imagen de Docker para su implementación en Elastic Beanstalk con una de las ramas de Docker en ejecución o *de* plataforma. AL2 AL2023 Los archivos de configuración que necesitará dependerán de si las imágenes son locales o remotas y de si utiliza Docker Compose.

**nota**  
 Para ver un ejemplo de un procedimiento que inicia un entorno de Docker, consulte el tema [QuickStart para Docker](docker-quickstart.md).

**Topics**
+ [Administración de imágenes con Docker Compose en Elastic Beanstalk](#single-container-docker-configuration-dc)
+ [Administración de imágenes sin Docker Compose en Elastic Beanstalk](#single-container-docker-configuration.no-compose)
+ [Creación de imágenes personalizadas con un Dockerfile](#single-container-docker-configuration.dockerfile)

## Administración de imágenes con Docker Compose en Elastic Beanstalk
<a name="single-container-docker-configuration-dc"></a>

Puede usar Docker Compose para administrar varios servicios en un archivo YAML. Para obtener más información sobre Docker Compose, consulte [¿Por qué usar Compose?](https://docs.docker.com/compose/intro/features-uses/) en el sitio web de Docker.
+ Creación de una `docker-compose.yml`. Este archivo es necesario si utiliza Docker Compose para administrar la aplicación con Elastic Beanstalk. No se requieren otros archivos de configuración si todas las implementaciones provienen de imágenes de repositorios públicos. Si las imágenes de origen de la implementación se encuentran en un repositorio privado, tendrá que realizar alguna configuración adicional. Para obtener más información, consulte [Uso de imágenes de un repositorio privado](docker-configuration.remote-repo.md). Para obtener más información sobre el archivo `docker-compose.yml`, consulte [Compose file reference](https://docs.docker.com/compose/compose-file/) en el sitio web de Docker.
+  La `Dockerfile` es opcional. Cree uno para que Elastic Beanstalk cree y ejecute una imagen personalizada local. Para obtener más información acerca de `Dockerfile`, consulte [Dockerfile reference (Referencia de Dockerfile)](https://docs.docker.com/engine/reference/builder/) en el sitio web de Docker.
+  Es posible que deba crear un archivo `.zip`. Si utiliza únicamente un archivo `Dockerfile` para implementar la aplicación, no es necesario crearlo. Si utiliza archivos de configuración adicionales, el archivo zip debe incluir el `Dockerfile`, el archivo `docker-compose.yml`, los archivos de la aplicación y cualquier dependencia de los archivos de la aplicación. `Dockerfile` y `docker-compose.yml` deben estar en la raíz o en el nivel superior del archivo zip. Si utiliza la CLI de EB para implementar la aplicación, se creará un archivo zip automáticamente.

Para obtener más información sobre Docker Compose y cómo instalarlo, consulte los sitios de Docker [Overview of Docker Compose](https://docs.docker.com/compose/) e [Install Docker Compose](https://docs.docker.com/compose/install/).

## Administración de imágenes sin Docker Compose en Elastic Beanstalk
<a name="single-container-docker-configuration.no-compose"></a>

Si no utiliza Docker Compose para administrar las imágenes de Docker, tendrá que configurar un `Dockerfile`, un archivo `Dockerrun.aws.json` o ambos.
+ Cree un `Dockerfile` para que Elastic Beanstalk cree y ejecute una imagen personalizada localmente.
+ Cree un archivo `Dockerrun.aws.json v1` para implementar una imagen de Docker de un repositorio alojado en Elastic Beanstalk.
+ Es posible que deba crear un archivo `.zip`. Si usa *solo uno* de los archivos, `Dockerfile` o `Dockerrun.aws.json`, no necesita crear un archivo zip. Si usa ambos archivos, necesitará un archivo zip. El archivo zip debe incluir `Dockerfile` y `Dockerrun.aws.json`, así como el archivo que contiene los archivos de la aplicación y cualquier dependencia de los archivos de la aplicación. Si utiliza la CLI de EB para implementar la aplicación, se creará un archivo `.zip` automáticamente.

### Archivo de configuración`Dockerrun.aws.json` v1
<a name="single-container-docker-configuration.dockerrun"></a>

Un archivo `Dockerrun.aws.json` describe cómo implementar una imagen remota de Docker como una aplicación de Elastic Beanstalk. Este archivo JSON es específico de Elastic Beanstalk. Si la aplicación se ejecuta en una imagen que está disponible en un repositorio alojado, puede especificar la imagen en un archivo `Dockerrun.aws.json v1` y omitir el archivo `Dockerfile`.

**Versiones de `Dockerrun.aws.json`**  
 El parámetro `AWSEBDockerrunVersion` indica la versión del archivo `Dockerrun.aws.json`.  
El Docker AL2 y AL2023 las plataformas utilizan las siguientes versiones del archivo.  
`Dockerrun.aws.json v3`: entornos que usan Docker Compose.
`Dockerrun.aws.json v1`: entornos que no utilizan Docker Compose.
El *ECS que se ejecuta en Amazon Linux 2* y el *ECS que se ejecuta en* Amazon AL2023 utilizan el `Dockerrun.aws.json v2` archivo. La plataforma retirada *ECS-Multicontainer Docker Amazon Linux AMI (AL1)* también utilizaba esta misma versión.



#### Dockerrun.aws.json v1
<a name="single-container-docker-configuration.dockerrun.awsjson"></a>

Las claves y los valores válidos para el archivo `Dockerrun.aws.json v1` se definen con las siguientes operaciones:

**AWSEBDockerrunVersión**  
(Obligatorio) Especifique el número de versión `1` si no utiliza Docker Compose para administrar la imagen.

**Autenticación**  
(Obligatorio solo para repositorios privados) Especifica el objeto de Amazon S3 que almacena el archivo `.dockercfg`.  
Consulte [Autenticación con repositorios de imágenesUsando AWS Secrets Manager](docker-configuration.remote-repo.md#docker-configuration.remote-repo.dockerrun-aws) en *Uso de imágenes de un repositorio privado* más adelante en este capítulo.

**Imagen**  
Especifica la imagen base de Docker en un repositorio Docker existente desde el que va a crear un contenedor Docker. Especifique el valor de la clave de **nombre** en el formato *<organization>/<image name>* de las imágenes de Docker Hub o *<site>/<organization name>/<image name>* de otros sitios.   
Cuando especifica una imagen en el archivo `Dockerrun.aws.json`, cada instancia del entorno de Elastic Beanstalk ejecuta `docker pull` para ejecutar la imagen. Si lo desea, incluya la clave **Update (Actualización de)**. El valor predeterminado es `true` e indica a Elastic Beanstalk que consulte el repositorio, inserte las actualizaciones en la imagen y sobrescriba las imágenes en caché.  
Cuando utilice un archivo `Dockerfile`, no especifique la clave **Image** en el archivo `Dockerrun.aws.json`. Elastic Beanstalk siempre crea y usa la imagen descrita en el archivo `Dockerfile` si hay alguna.

**Puertos**  
(Obligatorio si especifica la clave **Image**) Muestra los puertos que se exponen en el contenedor Docker. Elastic Beanstalk **ContainerPort**usa el valor para conectar el contenedor de Docker al proxy inverso que se ejecuta en el host.  
Puede especificar varios puertos de contenedor, pero Elastic Beanstalk solo utiliza el primer puerto. Utiliza este puerto para conectar el contenedor al proxy inverso del host y para enrutar las solicitudes de la Internet pública. **Si utiliza un`Dockerfile`, el primer **ContainerPort**valor debe coincidir con la primera entrada de la lista EXPOSE`Dockerfile`.**   
Si lo desea, puede especificar una lista de puertos de entrada **HostPort**. **HostPort**las entradas especifican los puertos del host a **ContainerPort**los que se asignan los valores. Si no especificas un **HostPort**valor, el valor predeterminado será el **ContainerPort**valor.   

```
{
  "Image": {
    "Name": "image-name"
  },
  "Ports": [
    {
      "ContainerPort": 8080,
      "HostPort": 8000
    }
  ]
}
```

****Volúmenes****  
Asigne volúmenes de una instancia de EC2 a su contenedor Docker. Especifique una o varias matrices de volúmenes que desee asignar.  

```
{
  "Volumes": [
    {
      "HostDirectory": "/path/inside/host",
      "ContainerDirectory": "/path/inside/container"
    }
  ]
...
```

****Registro****  
Especifique el directorio dentro del contenedor en el que la aplicación escribe los registros. Elastic Beanstalk carga todos los registros de este directorio en Amazon S3 cuando solicita registros de cola o paquete. Si rota los logs en una carpeta con el nombre `rotated` dentro de este directorio, también puede configurar Elastic Beanstalk para que cargue los logs rotados en Amazon S3 para su almacenamiento permanente. Para obtener más información, consulte [Visualización de registros de instancias de Amazon EC2 en su entorno de Elastic Beanstalk](using-features.logging.md).

**Comando**  
Especifique un comando para ejecutarlo en el contenedor. Si especifica un **punto de entrada** y, a continuación, se añade **Command (Comando)** como argumento en el **punto de entrada**. Para obtener más información, consulte [CMD](https://docs.docker.com/engine/reference/run/#cmd-default-command-or-options) en la documentación de Docker.

**Punto de entrada**  
Especifique un comando predeterminado para ejecutarse cuando se inicia el contenedor. Para obtener más información, consulte [ENTRYPOINT](https://docs.docker.com/engine/reference/run/#cmd-default-command-or-options) en la documentación de Docker.

El siguiente fragmento es un ejemplo que ilustra la sintaxis del archivo `Dockerrun.aws.json` para un solo contenedor.

```
{
  "AWSEBDockerrunVersion": "1",
  "Image": {
    "Name": "janedoe/image",
    "Update": "true"
  },
  "Ports": [
    {
      "ContainerPort": "1234"
    }
  ],
  "Volumes": [
    {
      "HostDirectory": "/var/app/mydb",
      "ContainerDirectory": "/etc/mysql"
    }
  ],
  "Logging": "/var/log/nginx",
  "Entrypoint": "/app/bin/myapp",
  "Command": "--argument"
}>
```

Puede proporcionar a Elastic Beanstalk solo el archivo `Dockerrun.aws.json` o un archivo `.zip` que contenga los archivos `Dockerrun.aws.json` y `Dockerfile`. Cuando proporciona ambos archivos, el archivo `Dockerfile` describe la imagen de Docker y el archivo `Dockerrun.aws.json` proporciona información adicional para la implementación tal y como se describe más adelante en esta sección.

**nota**  
Los dos archivos deben estar en la raíz, o en el nivel superior, del archivo `.zip`. No cree el archivo de almacenamiento desde un directorio que contenga los archivos. En lugar de ello, desplácese hasta ese directorio y cree allí el archivo de almacenamiento.  
Cuando proporcione ambos archivos, no especifique una imagen en el archivo `Dockerrun.aws.json`. Elastic Beanstalk crea y usa la imagen descrita en `Dockerfile` e ignora la imagen especificada en el archivo `Dockerrun.aws.json`.

## Creación de imágenes personalizadas con un Dockerfile
<a name="single-container-docker-configuration.dockerfile"></a>

Tendrá que crear un archivo `Dockerfile` si aún no dispone de una imagen alojada en un repositorio.

El siguiente fragmento es un ejemplo del archivo `Dockerfile`. Cuando siga las instrucciones de [QuickStart para Docker](docker-quickstart.md), podrá cargar este archivo `Dockerfile` tal como está escrito. Elastic Beanstalk ejecuta el juego 2048 cuando se utiliza este `Dockerfile`.

Para obtener más información sobre las instrucciones que puede incluir en el archivo `Dockerfile`, consulte la [referencia de Dockerfile](https://docs.docker.com/engine/reference/builder) en el sitio web de Docker.

```
FROM ubuntu:12.04

RUN apt-get update
RUN apt-get install -y nginx zip curl

RUN echo "daemon off;" >> /etc/nginx/nginx.conf
RUN curl -o /usr/share/nginx/www/master.zip -L https://codeload.github.com/gabrielecirulli/2048/zip/master
RUN cd /usr/share/nginx/www/ && unzip master.zip && mv 2048-master/* . && rm -rf 2048-master master.zip

EXPOSE 80

CMD ["/usr/sbin/nginx", "-c", "/etc/nginx/nginx.conf"]
```

**nota**  
Puede ejecutar compilaciones de varias etapas a partir de un solo Dockerfile para producir imágenes de menor tamaño con una reducción significativa de la complejidad. Para obtener más información, consulte [Utilizar compilaciones de varias etapas](https://docs.docker.com/develop/develop-images/multistage-build/) en el sitio web de documentación de Docker.