Arquitectura de Docker: contenedores, imágenes y registros.

Docker: Plataforma de Virtualización de Contenedores

Docker es una plataforma de virtualización de contenedores que permite ejecutar aplicaciones en entornos aislados y portátiles. La arquitectura básica de Docker se compone de tres elementos principales:

1. Contenedores: Un contenedor es una instancia aislada y ejecutable de un servicio o aplicación. Contiene todo lo necesario para que el software funcione, incluyendo el código, las bibliotecas y las dependencias. A diferencia de las máquinas virtuales tradicionales, los contenedores comparten el mismo núcleo del sistema operativo host, lo que los hace más ligeros y eficientes que las VMs.

2. Imágenes: Una imagen es una plantilla o modelo de un contenedor. Contiene el sistema de archivos y las dependencias necesarias para ejecutar una aplicación en un contenedor aislado. Las imágenes se crean a partir de un archivo de definición llamado Dockerfile, que especifica la configuración del entorno en el que se ejecutará el contenedor.

3. Registros: Un registro es un repositorio de imágenes de Docker. Los registros pueden ser públicos o privados y permiten el almacenamiento y distribución de imágenes de Docker en un entorno seguro y escalable. El registro de Docker por defecto es Docker Hub, el cual permite a los usuarios descargar y compartir imágenes de Docker públicas.

En resumen, los contenedores de Docker se basan en imágenes, que se almacenan en registros. Los contenedores aíslan las aplicaciones de otros procesos y entornos, lo que los hace portátiles y escalables. Las imágenes contienen todo lo necesario para que los contenedores se ejecuten, lo que los hace fácilmente reproducibles y escalables en diferentes entornos. Los registros permiten la gestión segura y el almacenamiento de imágenes en un entorno escalable y distribuido.

Un ejemplo práctico de la arquitectura de Docker podría ser el siguiente: Supongamos que tenemos una aplicación web desarrollada en Node.js, junto con una Base de Datos MySQL para almacenar información. Utilizaremos Docker para crear contenedores independientes para cada uno de estas aplicaciones, lo que nos permitirá empaquetar y distribuir nuestra aplicación de manera fácil y rápida. Para ello, primero creamos un archivo Dockerfile que especifica las instrucciones para construir la imagen de nuestra aplicación de Node.js y otro Dockerfile para la imagen de la base de datos MySQL. Luego construimos las imágenes utilizando estos archivos:

docker build -t miappnode:latest .
docker build -t mibasedatosmysql:latest .

Con nuestras imágenes construidas, podemos crear contenedores utilizando los comandos:

docker run -d --name miappnode miappnode:latest
docker run -d --name mibasedatosmysql mibasedatosmysql:latest

Esto creará dos contenedores completamente separados, uno para nuestra aplicación Node.js y otro para nuestra base de datos MySQL, cada uno de los cuales tendrá su propia información y configuración aislada. Finalmente, podemos utilizar un registro de Docker como Docker Hub para almacenar nuestras imágenes y compartirlos con otros desarrolladores. Para ello, podemos iniciar sesión con nuestra cuenta de Docker Hub y enviar nuestras imágenes utilizando el comando:

docker push nombreusuario/miappnode:latest
docker push nombreusuario/mibasedatosmysql:latest

Y así, cualquier otra persona puede descargar y ejecutar estas imágenes en sus propias máquinas simplemente utilizando el comando:

docker pull nombreusuario/miappnode:latest
docker pull nombreusuario/mibasedatosmysql:latest

Esta es la arquitectura de Docker en la que los contenedores aíslan las aplicaciones y las funciones de un sistema operativo y comparten recursos del mismo para el alojamiento. Las imágenes de Docker contienen la definición de las aplicaciones y los recursos de alojamiento. Los registros de Docker son repositorios en los que se almacenan las imágenes para poder compartirlas con otros usuarios y máquinas en la red.

Supongamos que tienes una aplicación en Python que utiliza una base de datos PostgreSQL y quieres ponerla en producción utilizando contenedores Docker. Primero, crearías un archivo Dockerfile que describa la imagen de Docker que necesitas para que tu aplicación funcione correctamente. Podría verse así:

FROM python:3.8
RUN apt-get update && \
    apt-get install -y postgresql-client
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r /app/requirements.txt
COPY . /app/
WORKDIR /app/
CMD python app.py

Este Dockerfile comienza con una imagen de Python, agrega el cliente de PostgreSQL, instala las dependencias, copia el código fuente de la aplicación y luego especifica que el comando predeterminado debe ser ejecutar "app.py".

Luego, construirías la imagen ejecutando docker build en el directorio que contiene el archivo Dockerfile:

$ docker build -t mi-aplicacion .

Después de que Docker crea la imagen, puedes ejecutar un contenedor basado en esa imagen con el siguiente comando:

$ docker run -d --name mi-contenedor -p 80:5000 mi-aplicacion

Aquí, estás ejecutando un contenedor a partir de la imagen que acabas de crear (mi-aplicacion), dándole un nombre (mi-contenedor) y mapeando el puerto 5000 de la aplicación al puerto 80 del host.

Finalmente, registras la imagen en un registro, como Docker Hub, para que otros miembros del equipo puedan descargarla y utilizarla:

$ docker push mi-usuario/mi-repositorio:mi-etiqueta

Aquí, estás empujando la imagen que acabas de crear a un repositorio de Docker (con el nombre de usuario y repositorio que hayas especificado) y le estás dando una etiqueta para que sea fácil de identificar.