Implementación de aplicaciones web y bases de datos con Docker.

Implementación de Aplicaciones Web y Bases de Datos con Docker

Docker es una plataforma que permite desarrollar, enviar y ejecutar aplicaciones de forma independiente de la infraestructura subyacente. Proporciona un entorno consistente en todas las etapas del ciclo de vida de una aplicación: desarrollo, pruebas y producción.

Implementación de Aplicaciones Web con Docker:

1. Creación de una Imagen Docker:

   • Define un archivo de recetas llamado Dockerfile que especifica los pasos necesarios para construir la imagen de tu aplicación.
   • La imagen incluye el código de tu aplicación, sus dependencias y configuraciones requeridas.

2. Ejecución en Contenedores:

   • Un contenedor es una instancia de ejecución de una imagen Docker.
   • Los contenedores son livianos y portátiles, ya que comparten la configuración de la imagen original.
   • Puedes iniciar, detener o eliminar contenedores en cuestión de segundos.

Implementación de Bases de Datos con Docker:

1. Uso de Contenedores de Bases de Datos:

   • Ejecuta contenedores de bases de datos listos para usar con Docker.
   • Separar la base de datos en un contenedor aparte de la aplicación web mejora la seguridad y el aislamiento.

2. Configuración de la Base de Datos:

   • Al iniciar un contenedor de base de datos, configura la contraseña y otros parámetros necesarios para la conexión.

3. Persistencia de Datos:

   • Utiliza volúmenes de Docker para mantener los datos persistentes.
   • Si el contenedor se detiene, los datos permanecen en el volumen y pueden reutilizarse en otro contenedor.

En resumen, para implementar aplicaciones web y bases de datos con Docker, crea imágenes Docker de tu aplicación y utiliza contenedores de bases de datos preconfigurados. Luego, ejecuta estos contenedores en tu servidor, asegurándote de configurar correctamente la conexión a la base de datos y mantener los datos persistentes mediante volúmenes de Docker.

Un ejemplo práctico:

Imaginemos que queremos poner en marcha una aplicación web con su base de datos en un contenedor de Docker. Para este ejemplo, supongamos que estamos trabajando con una aplicación desarrollada en Node.js y una base de datos MySQL.

Crear un archivo Dockerfile para la aplicación web:

FROM node:12
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD [ "npm", "start" ]
  

Este archivo Dockerfile utiliza una imagen base de Node.js, crea un directorio de trabajo en la ruta /app, copia los archivos package.json y package-lock.json en el directorio de trabajo, instala las dependencias de Node.js a través de npm install, y expone el puerto 3000. Por último, establece el comando para iniciar la aplicación a través de npm start.

Crear un archivo Dockerfile para la base de datos:

FROM mysql:5.7
ENV MYSQL_DATABASE=db_name \
    MYSQL_USER=db_user \
    MYSQL_PASSWORD=db_password \
    MYSQL_ROOT_PASSWORD=root_password
COPY init.sql /docker-entrypoint-initdb.d/
  

En este archivo Dockerfile, usamos una imagen base de MySQL versión 5.7, establecemos las variables de entorno para la creación de la base de datos, el usuario y la contraseña, y copiamos el archivo init.sql en la ruta /docker-entrypoint-initdb.d/. Este archivo es un script SQL que se ejecutará una vez que se haya iniciado el contenedor de MySQL y se encargará de crear las tablas necesarias y hacer cualquier configuración necesaria para la base de datos.

Utilizar docker-compose para la gestión de contenedores:

version: '3'
services:
  db:
    build:
      context: .
      dockerfile: Dockerfile.db
    restart: always
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: root_password
      MYSQL_DATABASE: db_name
      MYSQL_USER: db_user
      MYSQL_PASSWORD: db_password
  web:
    build:
      context: .
      dockerfile: Dockerfile.web
    restart: always
    ports:
      - "3000:3000"
    depends_on:
      - db
    volumes:
volumes:
  db_data:
  

Este archivo docker-compose.yml define dos servicios: db y web. El servicio db utiliza el archivo Dockerfile para crear la imagen de la base de datos. Además, se utiliza restart: always para garantizar que el contenedor de la base de datos se reinicie automáticamente si se detiene por alguna razón. También crea un volumen de datos llamado db_data para persistir la información en la base de datos incluso si se elimina y se vuelve a crear el contenedor. El servicio web utiliza el archivo Dockerfile la imagen para la aplicación web, y expone el puerto 3000. También depende del servicio db, por lo que Docker esperará hasta que el contenedor de la base de datos esté arriba antes de crear el contenedor de la aplicación web.

Con estas configuraciones en el archivo docker-compose.yml, podemos poner en marcha toda la aplicación con el siguiente comando:

docker-compose up -d
  

El parámetro -d se utiliza para poner los servicios en segundo plano.

Y aquí lo tienes, una aplicación web y una base de datos en un contenedor Docker. Esto simplifica la gestión y el despliegue de la aplicación, y además nos asegura que la aplicación y la base de datos trabajarán juntos sin conflictos.

Implementación de una Aplicación Web y una Base de Datos utilizando Docker y Python:

1. Primero, necesitamos crear un archivo llamado Dockerfile en nuestra raíz de proyecto. Este archivo contendrá las instrucciones para crear la imagen de Docker de nuestra aplicación web. Aquí te muestro un ejemplo básico:

   
   FROM python:3.9
   WORKDIR /app
   COPY requirements.txt .
   RUN pip install --no-cache-dir -r requirements.txt
   COPY . .
   CMD [ "python", "./app.py" ]
   EXPOSE 5000
         

   La imagen de Docker se creará utilizando la imagen base de Python 3.9. También le indicamos a Docker que cree un directorio de trabajo /app, copie el requirements.txt y instale las dependencias. Finalmente, le decimos a Docker que copie todo nuestro código fuente en el directorio /app y ejecute el archivo app.py para iniciar nuestra aplicación web. Además, exponemos el puerto 5000 para que podamos acceder a nuestra aplicación desde fuera del contenedor.

2. Después de crear el archivo Dockerfile, necesitamos construir la imagen de Docker. Corremos el siguiente comando en nuestra terminal en el directorio raíz del proyecto:

   
   docker build -t miapp:latest .
         

   Este comando construirá la imagen de Docker utilizando nuestro Dockerfile.

3. Ahora, necesitamos crear un contenedor utilizando nuestra imagen de Docker. Corremos el siguiente comando en nuestra terminal:

   
   docker run -p 5000:5000 --name miapp-container miapp:latest
         

   Este comando creará un contenedor con nuestra imagen de Docker, lo llamará miapp-container, y mapeará el puerto 5000 del contenedor al puerto 5000 de nuestra computadora para que podamos acceder a nuestra aplicación desde nuestro navegador.

4. Además, necesitamos crear un contenedor para nuestra base de datos. Aquí usaremos PostgreSQL como ejemplo.

   
   docker run --name db-container -e POSTGRES_PASSWORD=password -d postgres:latest
         

   Este comando creará un contenedor con la imagen de PostgreSQL y lo llamará db-container. También establecerá una contraseña para el usuario de PostgreSQL como "password".

5. Finalmente, necesitamos conectar nuestra aplicación web y nuestra base de datos. En nuestro código fuente de Python, podemos usar la librería psycopg2 para conectarnos con nuestra base de datos. Por ejemplo:

   
   import psycopg2
   conn = psycopg2.connect(
       database="postgres",
       user="postgres",
       password="password",
       host="localhost",
       port="5432"
   )
         

   Aquí establecemos una conexión con nuestra base de datos usando psycopg2 y las credenciales que configuramos en el contenedor de PostgreSQL.

Con esto, tenemos una implementación básica de una aplicación web y una base de datos utilizando Docker y Python.