Dockerizando Repositorios

Introducción

El término “Dockerizar” se refiere al proceso de empaquetar una aplicación en un contenedor Docker. Un contenedor Docker es una unidad de software que contiene todo lo necesario para ejecutar una aplicación, incluidas las dependencias, el código y las configuraciones. Docker es una herramienta que permite a los desarrolladores empaquetar sus aplicaciones en contenedores, lo que facilita la implementación y el despliegue de aplicaciones en diferentes entornos.

En esta guía, se describe cómo Dockerizar un repositorio de código fuente utilizando Docker y Docker Compose. Se explica cómo crear un archivo Dockerfile y un archivo docker-compose.yml para empaquetar una aplicación en un contenedor Docker y ejecutarla en un entorno local, calidad y producción.

Requisitos

Para seguir esta guía, es necesario tener instalado Docker y Docker Compose en su máquina local. Puede encontrar instrucciones detalladas sobre cómo instalar Docker y Docker Compose en la documentación oficial de Docker.

Además, es necesario tener un repositorio de código fuente en un sistema de control de versiones como Git o Gitea. Y ganas de aprender y experimentar con Docker y Docker Compose 🤓.

Creando un archivo Dockerfile

Supongamos que ya tienes tu proyecto terminado, sin bugs (o al menos eso esperamos) y quieres empaquetarlo en un contenedor Docker. Para ello, necesitas crear un archivo Dockerfile en la raíz de tu proyecto. Un archivo Dockerfile es un archivo de texto que contiene las instrucciones necesarias para construir una imagen de Docker.

Dado que en el equipo de Proyectos nuestros proyectos están desarrollados en Vite + Node.js, y React (Para el caso del frontend) y Java Spring Boot (Para el caso del backend), se mostraran ejemplos de Dockerfile para estos dos tipos de proyectos.

Entendiendo conceptos de Dockerfile

Un archivo Dockerfile consta de una serie de instrucciones que se ejecutan en orden para construir una imagen de Docker. Cada instrucción en un Dockerfile se representa mediante una palabra clave seguida de uno o más argumentos.

Imagen Base

Una imagen en Docker es un paquete de software ligero que contiene todo lo necesario para ejecutar una aplicación. Una imagen de Docker se compone de una serie de capas, cada una de las cuales contiene una parte de la configuración de la imagen. Las imágenes de Docker se almacenan en un registro de imágenes de Docker, como Docker Hub o un registro privado.

La primera instrucción en un Dockerfile es la instrucción FROM, que especifica la imagen base que se utilizará para construir la imagen de Docker. La imagen base es la imagen de Docker que se utilizará como punto de partida para construir la imagen de Docker.

Directorio de Trabajo

La instrucción WORKDIR se utiliza para especificar el directorio de trabajo dentro de la imagen de Docker. El directorio de trabajo es el directorio en el que se ejecutarán los comandos de la imagen de Docker. La instrucción WORKDIR se utiliza para cambiar el directorio de trabajo a un directorio específico dentro de la imagen de Docker.

Copiar Archivos

La instrucción COPY se utiliza para copiar archivos desde el sistema de archivos local a la imagen de Docker. La instrucción COPY toma dos argumentos: el origen y el destino. El origen es la ruta del archivo o directorio en el sistema de archivos local, y el destino es la ruta del archivo o directorio en la imagen de Docker.

Instalar Dependencias

La instrucción RUN se utiliza para ejecutar comandos en la imagen de Docker. La instrucción RUN toma un argumento que es el comando que se ejecutará en la imagen de Docker. La instrucción RUN se utiliza para instalar dependencias, compilar el código fuente y realizar otras tareas de construcción en la imagen de Docker.

Exponer Puertos

La instrucción EXPOSE se utiliza para exponer puertos en la imagen de Docker. La instrucción EXPOSE toma un argumento que es el número de puerto que se expondrá en la imagen de Docker. La instrucción EXPOSE se utiliza para especificar los puertos en los que la aplicación escuchará dentro del contenedor de Docker.

Comando de Inicio

La instrucción CMD se utiliza para especificar el comando que se ejecutará cuando se inicie el contenedor de Docker. La instrucción CMD toma un argumento que es el comando que se ejecutará cuando se inicie el contenedor de Docker. La instrucción CMD se utiliza para iniciar el servidor de la aplicación dentro del contenedor de Docker.

Etiqueta del Autor

La instrucción LABEL se utiliza para especificar metadatos sobre la imagen de Docker. La instrucción LABEL toma un argumento que es una clave-valor que especifica el metadato que se agregará a la imagen de Docker. La instrucción LABEL se utiliza para especificar el autor de la imagen de Docker.

Entendiendo conceptos de Docker Compose

Docker Compose es una herramienta que permite definir y ejecutar aplicaciones multi-contenedor en Docker. Docker Compose utiliza un archivo YAML llamado docker-compose.yml para definir la configuración de la aplicación, incluidos los servicios, las redes y los volúmenes que se utilizarán en la aplicación.

Un archivo docker-compose.yml consta de una serie de secciones que definen los servicios, las redes y los volúmenes que se utilizarán en la aplicación. Cada sección en un archivo docker-compose.yml se representa mediante una palabra clave seguida de uno o más argumentos.

Servicios

La sección services se utiliza para definir los servicios que se utilizarán en la aplicación. Cada servicio en un archivo docker-compose.yml se define mediante una serie de opciones que especifican la configuración del servicio, incluidas la imagen de Docker, los puertos, las variables de entorno y otros parámetros.

Redes

La sección networks se utiliza para definir las redes que se utilizarán en la aplicación. Cada red en un archivo docker-compose.yml se define mediante una serie de opciones que especifican la configuración de la red, incluidas la dirección IP, el rango de direcciones IP y otros parámetros.

Volúmenes

La sección volumes se utiliza para definir los volúmenes que se utilizarán en la aplicación. Cada volumen en un archivo docker-compose.yml se define mediante una serie de opciones que especifican la configuración del volumen, incluidas la ruta del volumen, el modo de montaje y otros parámetros.

Variables de Entorno

Las variables de entorno se utilizan para pasar información a los contenedores de Docker. Las variables de entorno se definen en un archivo docker-compose.yml mediante la opción environment en la sección de servicios. Las variables de entorno se utilizan para configurar la aplicación y personalizar su comportamiento.

Puertos

Los puertos se utilizan para exponer servicios en los contenedores de Docker. Los puertos se definen en un archivo docker-compose.yml mediante la opción ports en la sección de servicios. Los puertos se utilizan para acceder a los servicios de la aplicación desde el host o desde otros contenedores de Docker.

Ejemplos de Dockerfile + Docker Compose

Dockerfile para un proyecto Vite + Node.js

# Aqui vas a colocar la imagen base de Docker
FROM node:16 as build

# Aqui vas a colocar el directorio de trabajo
WORKDIR /app

# Aqui vas a copiar el package.json y package-lock.json
COPY package*.json ./

# Aqui vas a instalar las dependencias
RUN npm install

# Aqui vas a copiar el resto de los archivos
COPY . .

# Aqui vas a construir la aplicacion
RUN npm run build

# Aqui vas a colocar la imagen base de Docker
FROM nginx:alpine

# Aqui vas a copiar los archivos de la carpeta build
COPY --from=build /app/dist /usr/share/nginx/html

# Aqui vas a exponer el puerto 80
EXPOSE 80

# Aqui vas a iniciar el servidor de Nginx
CMD ["nginx", "-g", "daemon off;"]

# Aqui vas a colocar el autor del Dockerfile
LABEL maintainer="Tu Nombre"

Con este ejemplo de Dockerfile, puedes empaquetar un proyecto Vite + Node.js en un contenedor Docker y ejecutarlo en un entorno local, calidad y producción. Ya viene con un servidor Nginx para servir los archivos estáticos de la aplicación y exponer el puerto 80.

Docker Compose para un proyecto Vite + Node.js

version: "3.8"

# Aqui vas a colocar los servicios
services:
  # Aqui vas a colocar el nombre del servicio
  app:
    # Aqui vas a colocar la imagen de Docker
    build:
      context: .
      dockerfile: Dockerfile
    # Aqui vas a colocar el nombre del contenedor
    container_name: app
    # Aqui vas a colocar los puertos
    ports:
      - "8080:80"
    restart: always
    # Aqui vas a colocar las variables de entorno
    environment:
      - VIRTUAL_HOST=app.local
      - VIRTUAL_PORT=80
    # Aqui vas a colocar el network para comunicarte con el backend
    networks:
    app-network:
      driver: bridge

Con este ejemplo de Docker Compose, puedes definir un servicio para ejecutar un contenedor Docker con un proyecto Vite + Node.js en un entorno local, calidad y producción. Ya viene con la configuración necesaria para exponer el puerto 8080 y configurar el servidor Nginx.

Dockerfile para un proyecto Java Spring Boot

# Aqui vas a colocar la imagen base de Docker
FROM adoptopenjdk/openjdk16:alpine

# Aqui vas a copiar el archivo JAR
COPY target/*.jar app.jar

# Aqui vas a exponer el puerto 8080
EXPOSE 8080

# Aqui vas a iniciar la aplicacion
CMD ["java", "-jar", "app.jar"]

# Aqui vas a colocar el autor del Dockerfile
LABEL maintainer="Tu Nombre"

Y listo, asi de simple tenemos ya nuestro Dockerfile para empaquetar un proyecto Java Spring Boot en un contenedor Docker y ejecutarlo en un entorno local, calidad y producción.

Creando un archivo docker-compose.yml para un proyecto Java Spring Boot

version: "3.8"

# Aqui vas a colocar los servicios
services:
  # Aqui vas a colocar el nombre del servicio
  app:
    # Aqui vas a colocar la imagen de Docker
    build:
      context: .
      dockerfile: Dockerfile
    # Aqui vas a colocar el nombre del contenedor
    container_name: app
    # Aqui vas a colocar los puertos
    ports:
      - "8080:8080"
    restart: always
    # Aqui vas a colocar las variables de entorno
    environment:
      - VIRTUAL_HOST=app.local
      - VIRTUAL_PORT=8080
    # Aqui vas a colocar los volúmenes
    volumes:
      - ./target:/app/target
    # Aqui vas a colocar las redes para comunicarte con el frontend
    networks:
      - app-network

Con este ejemplo de Docker Compose, puedes definir un servicio para ejecutar un contenedor Docker con un proyecto Java Spring Boot en un entorno local, calidad y producción. Ya viene con la configuración necesaria para exponer el puerto 8080 y configurar el servidor de aplicaciones.

Realizando el Build y Run de los Contenedores

Una vez que hayas creado el archivo Dockerfile y el archivo docker-compose.yml, puedes realizar el build y run de los contenedores de Docker utilizando los siguientes comandos:

Build de los Contenedores

Para realizar el build de los contenedores de Docker, puedes utilizar el siguiente comando:

docker-compose build

Este comando construirá las imágenes de Docker para los servicios definidos en el archivo docker-compose.yml.

Run de los Contenedores

Para realizar el run de los contenedores de Docker, puedes utilizar el siguiente comando:

docker-compose up

Este comando ejecutará los contenedores de Docker para los servicios definidos en el archivo docker-compose.yml.

Con estos comandos, puedes empaquetar una aplicación en un contenedor Docker y ejecutarla en un entorno local, calidad y producción. Docker es una herramienta poderosa que facilita la implementación y el despliegue de aplicaciones en diferentes entornos.

Eliminar los Contenedores

Para eliminar los contenedores de Docker, puedes utilizar el siguiente comando:

docker-compose down

Este comando eliminará los contenedores de Docker para los servicios definidos en el archivo docker-compose.yml.