Cómo Dockerizar Tu Primera Aplicación

Docker ha revolucionado la forma en que los desarrolladores crean, implementan y gestionan aplicaciones. Al empaquetar las aplicaciones en contenedores, permite consistencia en diferentes entornos, haciendo que la implementación sea más directa y menos propensa a errores. En este artículo, profundizaremos en el proceso de Dockerizar tu primera aplicación, cubriendo tanto conceptos fundamentales como técnicas avanzadas. Al final, deberías tener un conocimiento exhaustivo de cómo aprovechar Docker para simplificar tu ciclo de vida de desarrollo.

Understanding the Basics of Docker

Before we jump into the practical aspects of Dockerizing an application, it’s crucial to understand some fundamental concepts.

Docker es una plataforma de código abierto que permite a los desarrolladores crear, implementar y ejecutar aplicaciones en contenedores. Los contenedores son entornos aislados que contienen todo lo necesario para que una aplicación se ejecute, incluyendo el código, las bibliotecas del sistema, las herramientas y las dependencias. Esto significa que las aplicaciones pueden ejecutarse de manera consistente en cualquier entorno, ya sea en un servidor local, en la nube o en un dispositivo móvil.Docker utiliza la tecnología de contenedores de Linux, que permite que múltiples contenedores se ejecuten en una sola máquina host. Cada contenedor comparte el kernel del sistema operativo host, pero tiene su propio espacio de usuario y sistema de archivos. Esto hace que los contenedores sean mucho más ligeros y rápidos que las máquinas virtuales tradicionales, que requieren un sistema operativo completo para cada instancia.Docker también proporciona una serie de herramientas y servicios para facilitar el desarrollo y la implementación de aplicaciones en contenedores. Estos incluyen:- Docker Hub: Un repositorio de imágenes de contenedores que los desarrolladores pueden usar como base para sus propias aplicaciones.- Docker Compose: Una herramienta para definir y ejecutar aplicaciones de múltiples contenedores.- Docker Swarm: Un orquestador de contenedores que permite a los desarrolladores administrar y escalar aplicaciones en contenedores en múltiples hosts.- Docker Machine: Una herramienta para crear y administrar máquinas host de Docker en diferentes plataformas.En resumen, Docker es una plataforma de contenedores que permite a los desarrolladores crear, implementar y ejecutar aplicaciones de manera consistente en cualquier entorno. Proporciona una serie de herramientas y servicios para facilitar el desarrollo y la implementación de aplicaciones en contenedores, lo que lo convierte en una opción popular para el desarrollo de aplicaciones modernas.

Docker is an open-source platform that automates the deployment of applications inside lightweight, portable containers. It encapsulates everything an application needs to run (code, runtime, libraries, and system tools) into a single package, which ensures that it runs consistently across various environments.

¿Qué son los contenedores?

Los contenedores son paquetes ligeros, autónomos y ejecutables que incluyen todo lo necesario para ejecutar un software. Están aislados entre sí y comparten el kernel del sistema operativo subyacente, lo que los hace más eficientes que las máquinas virtuales tradicionales.

Images vs. Containers

• Images: These are the blueprints of containers, composed of a series of layers stacked on top of each other. Each layer represents a change, such as installing software or copying files.
• ContenedoresUna instancia en ejecución de una imagen. Al iniciar una imagen, creas un contenedor.

Prerequisites

Antes de comenzar el proceso de dockerización, asegúrate de tener los siguientes prerrequisitos:

1. Docker está instaladoAsegúrate de que Docker esté instalado en tu sistema. Puedes descargarlo desde the official Docker website.
2. Conocimientos básicos de línea de comandos: You will be using the command line to interact with Docker.
3. Lenguaje de programación: While Docker can be used with any programming language, this article will use a simple Node.js application as an example.

Step 1: Creating Your Application

Para que este tutorial sea práctico, comencemos creando una aplicación Node.js simple.

Setting Up a Node.js Project

1. Create a project directory:

   mkdir mi-app-docker
   cd mi-app-docker

2. Para inicializar un nuevo proyecto Node.js, sigue estos pasos:1. Abre tu terminal o línea de comandos.2. Navega hasta el directorio donde quieres crear tu proyecto usando el comando `cd`. Por ejemplo: ``` cd Documents/my-projects ```3. Ejecuta el siguiente comando para inicializar un nuevo proyecto Node.js: ``` npm init ```4. Se te pedirá que ingreses información sobre tu proyecto, como el nombre, versión, descripción, punto de entrada, etc. Puedes presionar Enter para aceptar los valores predeterminados o ingresar tus propios valores.5. Una vez que hayas ingresado toda la información, se creará un archivo `package.json` en tu directorio. Este archivo contiene la configuración de tu proyecto Node.js.¡Listo! Has inicializado un nuevo proyecto Node.js. Ahora puedes comenzar a agregar dependencias y escribir tu código.:

   npm init -y

3. Express es una infraestructura de aplicaciones web Node.js mínima y flexible que proporciona un conjunto sólido de características para aplicaciones web y móviles.Para instalar Express, primero asegúrate de tener Node.js instalado en tu sistema. Luego, abre tu terminal o línea de comandos y navega hasta el directorio de tu proyecto.Una vez en el directorio del proyecto, ejecuta el siguiente comando para inicializar un nuevo proyecto Node.js:``` npm init -y ```Esto creará un archivo `package.json` en tu directorio con la configuración básica del proyecto.A continuación, instala Express como una dependencia de tu proyecto ejecutando:``` npm install express ```Esto descargará e instalará la última versión estable de Express en tu proyecto.Una vez completada la instalación, puedes verificar que Express se haya instalado correctamente verificando el archivo `package.json`. Deberías ver `express` listado en la sección de dependencias.Ahora estás listo para comenzar a usar Express en tu proyecto Node.js. Puedes importar Express en tus archivos JavaScript usando:```javascript const express = require('express'); ```Y luego crear una nueva aplicación Express:```javascript const app = express(); ```A partir de aquí, puedes definir rutas, middleware y otras configuraciones para tu aplicación web Express.¡Eso es todo! Has instalado y configurado correctamente Express en tu proyecto Node.js.:

   npm install express

4. Crear un archivo de aplicación:

   Create a file named app.js En el directorio del proyecto, y agregue el siguiente código:

   const express = require('express');
   const app = express();
   const PUERTO = process.env.PORT || 3000;
   
   app.get('/', (req, res) => {
       res.send('¡Hola, Docker!');
   });
   
   app.listen(PUERTO, () => {
       console.log(`El servidor se está ejecutando en el puerto ${PUERTO}`);
   });

Testing the Application Locally

Run the application locally to ensure it’s working before Dockerizing:

node app.js

Deberías ver el mensaje que indica que el servidor está funcionando. Abre un navegador web y navega a http://localhost:3000 para confirmar que ves "¡Hola, Docker!".

Step 2: Writing a Dockerfile

Un Dockerfile es un documento de texto que contiene todos los comandos necesarios para ensamblar una imagen.

Create a Dockerfile

En la raíz de tu directorio del proyecto, crea un archivo llamado Dockerfile (sin extensión) y añade el siguiente contenido:

# Use the official Node.js image from the Docker Hub
FROM node:14

# Set the working directory in the container
WORKDIR /usr/src/app

# Copy package.json and package-lock.json
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy the application code
COPY . .

# Expose the application port
EXPOSE 3000

# Define the command to run the application
CMD ["node", "app.js"]

Explicación de las Instrucciones del Dockerfile

• DE node:14Define la imagen base que estamos utilizando. En este caso, es la imagen oficial de Node.js.
• DIRECTORIO_DE_TRABAJO /usr/src/app: Sets the working directory inside the container.
• *COPIA paquete.json ./**: Copies the package.json and package-lock.json files to the working directory.
• RUN npm install (instalar paquetes npm): Instala las dependencias de la aplicación especificadas en package.json.
• COPIAR . .: Copia el resto del código de la aplicación en el contenedor.
• Exponer el puerto 3000: Informs Docker that the container listens on port 3000 at runtime.
• Símbolo del sistemaEspecifica el comando que se ejecutará cuando el contenedor se inicie.

Step 3: Building the Docker Image

Now that we have the Dockerfile set up, we can build the Docker image.

Construir la imagen

Ejecuta el siguiente comando desde el directorio raíz de tu proyecto:

docker build -t my-docker-app .

Understanding the Build Process

Durante el proceso de construcción, Docker lee las instrucciones del Dockerfile y las ejecuta paso a paso. El -t flag tags the image with a name (in this case, mi-aplicacion-docker), y el . indica el contexto de construcción (el directorio actual).

Una vez completada la compilación, puedes verificar que tu imagen existe ejecutando:

imágenes de docker

Paso 4: Ejecutar el contenedor DockerAhora que hemos creado nuestra imagen de Docker, podemos ejecutarla como un contenedor. Para hacer esto, usaremos el comando docker run. Aquí está la sintaxis básica:```bash docker run [opciones] imagen [comando] [argumentos] ```Las opciones más comunes incluyen:- `-d`: Ejecutar el contenedor en modo detached (en segundo plano). - `-p`: Mapear un puerto del contenedor a un puerto del host. - `-v`: Montar un volumen en el contenedor. - `--name`: Asignar un nombre al contenedor.Por ejemplo, para ejecutar nuestro contenedor de Nginx y mapear el puerto 80 del contenedor al puerto 8080 del host, usaríamos el siguiente comando:```bash docker run -d -p 8080:80 nginx ```Este comando iniciará un contenedor basado en la imagen de Nginx, lo ejecutará en modo detached y mapeará el puerto 80 del contenedor al puerto 8080 del host. Ahora, si visitas `http://localhost:8080` en tu navegador, deberías ver la página de bienvenida de Nginx.También podemos ejecutar comandos dentro de un contenedor en ejecución usando el comando `docker exec`. Por ejemplo, para ejecutar un comando bash dentro de nuestro contenedor de Nginx, usaríamos:```bash docker exec -it bash ```Esto abrirá una sesión de bash interactiva dentro del contenedor, permitiéndonos ejecutar comandos como si estuviéramos dentro del contenedor mismo.Recuerda que los contenedores son efímeros por naturaleza, lo que significa que cualquier cambio realizado en el sistema de archivos del contenedor se perderá cuando el contenedor se detenga. Si necesitas persistir datos, deberías usar volúmenes de Docker.En resumen, ejecutar contenedores Docker es un proceso sencillo que nos permite desplegar y ejecutar aplicaciones de manera rápida y consistente en diferentes entornos.

With the image built, the next step is to run a container from this image.

Run the Container

Ejecuta el siguiente comando para ejecutar tu aplicación:

docker run -p 3000:3000 my-docker-app

Explicación del comando RunEl comando Run es una herramienta poderosa que permite a los usuarios ejecutar programas, abrir archivos y acceder a funciones del sistema de manera rápida y eficiente. Esta función está disponible en la mayoría de los sistemas operativos Windows y puede ser accedida de varias maneras.Para abrir el comando Run, los usuarios pueden presionar la combinación de teclas Windows + R en su teclado. Alternativamente, pueden buscar "Run" en el menú de inicio o hacer clic derecho en el botón de inicio y seleccionar "Run" del menú contextual.Una vez abierto el cuadro de diálogo de Run, los usuarios pueden escribir comandos específicos para realizar diversas tareas. Algunos ejemplos comunes incluyen:1. Ejecutar programas: Escribir el nombre del programa o su ruta completa para abrirlo directamente.2. Abrir archivos: Ingresar la ruta completa de un archivo para abrirlo con su programa asociado.3. Acceder a funciones del sistema: Utilizar comandos predefinidos para acceder a herramientas del sistema, como "msconfig" para la configuración del sistema o "devmgmt.msc" para el administrador de dispositivos.4. Navegar a ubicaciones específicas: Escribir rutas de carpetas para abrir el Explorador de archivos directamente en esa ubicación.5. Ejecutar comandos de red: Utilizar comandos como "ping" o "ipconfig" para realizar tareas de diagnóstico de red.6. Acceder a herramientas administrativas: Ingresar comandos como "compmgmt.msc" para abrir la Consola de Administración de Computadoras.7. Ejecutar scripts o archivos por lotes: Escribir la ruta completa de un script o archivo por lotes para ejecutarlo.Es importante tener en cuenta que algunos comandos pueden requerir privilegios de administrador para ejecutarse correctamente. Además, los usuarios deben tener cuidado al ejecutar comandos desconocidos, ya que podrían afectar el funcionamiento del sistema.El comando Run también admite el uso de variables de entorno, lo que permite a los usuarios crear atajos personalizados para acceder rápidamente a ubicaciones o programas frecuentemente utilizados.En resumen, el comando Run es una herramienta versátil que ofrece a los usuarios una forma rápida y eficiente de interactuar con su sistema operativo y ejecutar diversas tareas sin necesidad de navegar a través de múltiples menús o interfaces gráficas.

• -p 3000:3000Mapea el puerto 3000 del host al puerto 3000 del contenedor. Esto permite acceder a la aplicación a través de http://localhost:3000.
• mi-aplicacion-docker: El nombre de la imagen a ejecutar.

Accessing the Application

Ir a http://localhost:3000 en tu navegador web. Deberías ver el mensaje "¡Hola, Docker!" que confirma que tu aplicación se está ejecutando correctamente dentro de un contenedor de Docker.

Step 5: Managing Your Containers

Listado de contenedores en ejecución

Para ver todos los contenedores que se están ejecutando actualmente, use:

docker ps

Detener y eliminar contenedoresCuando se ejecuta un contenedor, este se mantiene en ejecución hasta que se detiene. Para detener un contenedor, se puede utilizar el comando `docker stop` seguido del nombre o ID del contenedor. Por ejemplo:``` docker stop mi-contenedor ```Esto enviará una señal SIGTERM al proceso principal del contenedor, dándole la oportunidad de limpiar y detenerse de manera ordenada. Si el contenedor no se detiene dentro de un tiempo determinado (10 segundos por defecto), se enviará una señal SIGKILL para forzar su detención.Para eliminar un contenedor, se puede utilizar el comando `docker rm` seguido del nombre o ID del contenedor. Por ejemplo:``` docker rm mi-contenedor ```Esto eliminará el contenedor, pero no la imagen con la que fue creado. Si se desea eliminar tanto el contenedor como la imagen, se puede utilizar el comando `docker rmi` seguido del nombre o ID de la imagen. Por ejemplo:``` docker rmi mi-imagen ```Es importante tener en cuenta que eliminar un contenedor no elimina los datos que se hayan guardado en volúmenes o bind mounts. Si se desea eliminar también estos datos, se debe hacer de manera explícita utilizando los comandos `docker volume rm` o `docker system prune`.

Para detener un contenedor en ejecución, puedes usar:

docker stop 

To remove a container, use:

eliminar contenedor 

Removing Images

You can also remove images when they are no longer needed:

docker rmi my-docker-app

Paso 6: Usando Docker Compose

Para aplicaciones más complejas con múltiples servicios (como un servidor web, una base de datos, etc.), Docker Compose puede simplificar la gestión.

Installing Docker Compose

Docker Compose is included with Docker Desktop installations. If you’re on Linux, follow the official installation guide.

Crear un docker-compose.yml Archivo

In your project directory, create a file named docker-compose.yml with the following content:

version: '3'
services:
  web:
    build: .
    ports:
      - "3000:3000"

Ejecución con Docker ComposeDocker Compose es una herramienta para definir y ejecutar aplicaciones Docker de múltiples contenedores. Utiliza archivos YAML para configurar los servicios de tu aplicación. Luego, con un solo comando, creas e inicias todos los servicios desde tu configuración.Para obtener más información sobre todas las características de Docker Compose, consulta la lista de características.Para instalar Docker Compose, consulta Instalación de Docker Compose.Asegúrate de que Docker Compose esté instalado y funcionando correctamente ejecutando:$ docker-compose --versiondocker-compose version 1.25.0, build 0a186604Para ejecutar Compose, haz lo siguiente:1. Configura tu aplicación de Compose en un archivo docker-compose.yml.2. Con el comando docker-compose up, inicia y ejecuta toda tu aplicación. Puedes ejecutar docker-compose up -d para ejecutarlo en segundo plano.3. Ejecuta docker-compose ps para verificar el estado de los servicios.4. Para detenerlo, presiona CTRL+C. También puedes ejecutar docker-compose down o docker-compose stop.El siguiente comando de ejemplo inicia la aplicación de ejemplo descrita anteriormente.$ docker-compose up -dCreating network "alpine-net" with driver "bridge" Creating alpine1 Creating alpine2 Creating alpine3 Creating alpine4$ docker-compose psName Command State Ports ---------------------------------------------------------------------- alpine1 ping -c30 www.google.com Up alpine2 ping -c30 www.google.com Up alpine3 ping -c30 www.google.com Up alpine4 ping -c30 www.google.com UpPara detener la ejecución de la aplicación, ejecuta docker-compose down. Los contenedores se detienen y se eliminan. Los volúmenes de datos creados por docker-compose up se conservan.Para obtener más información sobre el comando docker-compose up, consulta docker-compose up.Para obtener más información sobre el comando docker-compose down, consulta docker-compose down.

Puede iniciar la aplicación y sus servicios con:```bash $ docker-compose up ```Si desea iniciar los servicios en segundo plano, puede agregar la opción `-d`:```bash $ docker-compose up -d ```Para detener los servicios, puede usar:```bash $ docker-compose down ```Si también desea eliminar los volúmenes de datos, puede agregar la opción `-v`:```bash $ docker-compose down -v ```

docker-compose up

Este comando construirá la imagen (si aún no se ha construido) e iniciará el contenedor definido en el docker-compose.yml.

Para detener los servicios, presione Ctrl+C o ejecuta:

docker-compose down

Step 7: Best Practices for Dockerizing Applications

Ahora que has logrado "Dockerizar" tu primera aplicación, aquí hay algunas mejores prácticas a tener en cuenta:

Mantén los Dockerfiles limpios

• Use builds multietapa para reducir el tamaño de la imagen separando las dependencias de desarrollo y producción.
• Evita capas innecesarias combinando comandos siempre que sea posible.

Usa .dockerignore

Crear un .dockerignore archivo en tu directorio del proyecto para excluir archivos y directorios que no deberían incluirse en la imagen (como node_modules, registros, etc.). Aquí tienes un ejemplo:

node_modules
npm-debug.log

Regularly Update Images

Asegúrate de actualizar regularmente tus imágenes base para aprovechar los parches de seguridad y las mejoras de rendimiento.

Conclusión

Dockerizar tu primera aplicación puede parecer abrumador al principio, pero siguiendo los pasos descritos en este artículo, puedes empaquetar con éxito tus aplicaciones en contenedores. Esto no solo agiliza el proceso de desarrollo, sino que también mejora la consistencia del despliegue en diferentes entornos.

A medida que te sientas más cómodo con Docker, explora funciones avanzadas como la orquestación con Kubernetes, redes y almacenamiento persistente. El ecosistema que rodea a Docker es amplio y sigue evolucionando, ofreciendo numerosas herramientas y prácticas para optimizar aún más la contenedorización. Con Docker como parte de tu kit de herramientas, puedes crear aplicaciones portables, escalables y mantenibles.

Ahora que tienes una comprensión básica de Docker, ¡es hora de experimentar, construir aplicaciones más complejas y adentrarte más en el mundo de la contenedorización! ¡Feliz Dockerización!