# Escribir un Dockerfile ## Explicación Un Dockerfile es un documento basado en texto que se utiliza para crear una imagen de contenedor. Proporciona instrucciones al constructor de imágenes sobre los comandos a ejecutar, los archivos a copiar, el comando de inicio y más. Como ejemplo, el siguiente Dockerfile produciría una aplicación de Python lista para ejecutarse: ```dockerfile FROM python:3.13 WORKDIR /usr/local/app # Instalar las dependencias de la aplicación COPY requirements.txt ./ RUN pip install --no-cache-dir -r requirements.txt # Copiar el código fuente COPY src ./src EXPOSE 8080 # Configurar un usuario de aplicación para que el contenedor no se ejecute como el usuario root RUN useradd app USER app CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"] ``` ### Instrucciones comunes Algunas de las instrucciones más comunes en un `Dockerfile` incluyen: - `FROM `: especifica la imagen base que extenderá la compilación. - `WORKDIR `: esta instrucción especifica el "directorio de trabajo" o la ruta en la imagen donde se copiarán los archivos y se ejecutarán los comandos. - `COPY `: esta instrucción indica al constructor que copie archivos desde el host y los coloque en la imagen del contenedor. - `RUN `: esta instrucción indica al constructor que ejecute el comando especificado. - `ENV `: esta instrucción establece una variable de entorno que utilizará un contenedor en ejecución. - `EXPOSE `: esta instrucción establece la configuración en la imagen para indicar un puerto que la imagen desea exponer. - `USER `: esta instrucción establece el usuario predeterminado para todas las instrucciones siguientes. - `CMD ["", ""]`: esta instrucción establece el comando predeterminado que ejecutará un contenedor que use esta imagen. Para leer todas las instrucciones o entrar en mayor detalle, consulta la [referencia de Dockerfile](https://docs-docker.esdocu.com/engine/reference/builder/). ## Pruébalo Tal como viste con el ejemplo anterior, un Dockerfile normalmente sigue estos pasos: 1. Determinar tu imagen base 2. Instalar las dependencias de la aplicación 3. Copiar cualquier código fuente y/o binarios relevantes 4. Configurar la imagen final En esta rápida guía práctica, escribirás un Dockerfile que compila una aplicación simple de Node.js. Si no estás familiarizado con las aplicaciones basadas en JavaScript, no te preocupes. No es necesario para seguir esta guía. ### Configuración [Descarga este archivo ZIP](https://github.com/docker/getting-started-todo-app/archive/refs/heads/build-image-from-scratch.zip) y extrae su contenido en un directorio de tu máquina. Si prefieres no descargar un archivo ZIP, clona el proyecto `https://github.com/docker/getting-started-todo-app` y realiza un checkout de la rama `build-image-from-scratch`. ### Crear el Dockerfile Ahora que tienes el proyecto, estás listo para crear el `Dockerfile`. 1. [Descarga e instala](https://www.docker.com/products/docker-desktop/) Docker Desktop. 2. Examina el proyecto. Explora el contenido de `getting-started-todo-app/app/`. Notarás que ya existe un `Dockerfile`. Es un archivo de texto simple que puedes abrir en cualquier editor de texto o de código. 3. Elimina el `Dockerfile` existente. Para este ejercicio, simularás que estás empezando desde cero y crearás un nuevo `Dockerfile`. 4. Crea un archivo llamado `Dockerfile` en la carpeta `getting-started-todo-app/app/`. > **Extensiones de archivo del Dockerfile** > > Es importante tener en cuenta que el `Dockerfile` _no_ tiene extensión de archivo. Algunos editores añadirán automáticamente una extensión al archivo (or complain it doesn't have one). 5. In el `Dockerfile`, define tu imagen base añadiendo la siguiente línea: ```dockerfile FROM node:22-alpine ``` 6. Ahora, define el directorio de trabajo utilizando la instrucción `WORKDIR`. Esto especificará dónde se ejecutarán los comandos futuros y la ruta donde se copiarán los archivos dentro de la imagen del contenedor. ```dockerfile WORKDIR /app ``` 7. Copia todos los archivos de tu proyecto en tu máquina a la imagen del contenedor utilizando la instrucción `COPY`: ```dockerfile COPY . . ``` 8. Instala las dependencias de la aplicación utilizando la CLI de `yarn` y su gestor de paquetes. Para hacerlo, ejecuta un comando utilizando la instrucción `RUN`: ```dockerfile RUN yarn install --production ``` 9. Finalmente, especifica el comando predeterminado a ejecutar utilizando la instrucción `CMD`: ```dockerfile CMD ["node", "./src/index.js"] ``` Y con eso, deberías tener el siguiente Dockerfile: ```dockerfile FROM node:22-alpine WORKDIR /app COPY . . RUN yarn install --production CMD ["node", "./src/index.js"] ``` > **Este Dockerfile aún no está listo para producción** > > Es importante tener en cuenta que este Dockerfile _no_ sigue todas las mejores prácticas todavía (por diseño). Compilará la aplicación, pero las compilaciones no serán tan rápidas ni las imágenes tan seguras como podrían serlo. > > Sigue leyendo para aprender más sobre cómo hacer que la imagen maximice la caché de compilación, se ejecute como un usuario no root y sobre las compilaciones multietapa. > **Contenedoriza nuevos proyectos rápidamente con `docker init`** > > El comando `docker init` analizará tu proyecto y creará rápidamente un Dockerfile, un archivo `compose.yaml` y un `.dockerignore`, ayudándote a ponerte en marcha. Dado que aquí estás aprendiendo específicamente sobre Dockerfiles, no lo usarás ahora. Sin embargo, [obtén más información al respecto aquí](/reference/cli/docker/init/). ## Recursos adicionales Para obtener más información sobre cómo escribir un Dockerfile, visita los siguientes recursos: - [Referencia de Dockerfile](/reference/dockerfile/) - [Mejores prácticas de Dockerfile](/develop/develop-images/dockerfile_best-practices/) - [Imágenes base](/build/building/base-images/) - [Primeros pasos con Docker Init](/reference/cli/docker/init/) ## Siguientes pasos Ahora que has creado un Dockerfile y aprendido los conceptos básicos, es hora de aprender a compilar, etiquetar y subir las imágenes. [Compilar, etiquetar y publicar la imagen](/get-started/docker-concepts/building-images/writing-a-dockerfile/build-tag-and-publish-an-image)