Ejecutar aplicación Python en contenedor Docker: Guía completa

Introducción

Docker se ha convertido en un cambio de juego en el mundo del desarrollo de software, permitiendo a los desarrolladores empaquetar sus aplicaciones y dependencias en unidades portátiles y autocontenidas llamadas contenedores. En este tutorial, te guiaremos a través del proceso de ejecutar una aplicación Python en un contenedor Docker, cubriendo los pasos esenciales desde la comprensión de Docker hasta la implementación de la aplicación contenida.

Entendiendo Docker

¿Qué es Docker?

Docker es una plataforma de código abierto que permite a los desarrolladores construir, desplegar y ejecutar aplicaciones en un entorno contenedorizado. Los contenedores son paquetes de software ligeros, autónomos y ejecutables que incluyen todo lo necesario para ejecutar una aplicación, incluyendo el código, el tiempo de ejecución, las herramientas del sistema y las bibliotecas. Docker proporciona una forma de empaquetar y distribuir estos contenedores, lo que facilita el despliegue y la gestión de aplicaciones en diferentes entornos.

Beneficios de Usar Docker

Consistencia: Los contenedores Docker garantizan que la aplicación se ejecute de la misma manera, independientemente de la infraestructura subyacente.
Escalabilidad: Docker facilita la escalabilidad de las aplicaciones, aumentando o disminuyendo la capacidad según sea necesario, agregando o eliminando contenedores.
Eficiencia: Los contenedores Docker son ligeros y utilizan menos recursos que las máquinas virtuales tradicionales, permitiendo un uso más eficiente de los recursos informáticos.
Portabilidad: Los contenedores Docker se pueden mover fácilmente entre diferentes entornos, como desarrollo, pruebas y producción, sin necesidad de cambios de configuración complejos.

Arquitectura de Docker

La arquitectura de Docker se basa en un modelo cliente-servidor, donde el cliente Docker se comunica con el demonio Docker, que es responsable de construir, ejecutar y gestionar los contenedores Docker. Los componentes clave de la arquitectura de Docker incluyen:

graph LR
    A[Cliente Docker] -- Se comunica con --> B[Demonio Docker]
    B -- Gestiona --> C[Imágenes Docker]
    B -- Gestiona --> D[Contenedores Docker]
    B -- Gestiona --> E[Volúmenes Docker]
    B -- Gestiona --> F[Redes Docker]

Comenzando con Docker

Para comenzar con Docker, necesitarás instalar el motor Docker en tu sistema. Puedes descargar e instalar Docker desde el sitio web oficial de Docker (https://www.docker.com/get-started). Una vez instalado, puedes usar la interfaz de línea de comandos (CLI) docker para interactuar con el demonio Docker y gestionar tus contenedores.

Aquí hay un ejemplo de cómo ejecutar un contenedor simple "Hola, Mundo!" usando Docker:

$ docker run hello-world

Este comando extraerá la imagen hello-world del registro Docker Hub, creará un nuevo contenedor y ejecutará la aplicación dentro del contenedor.

Contenizando una Aplicación Python

Creando una Imagen Docker para una Aplicación Python

Para contener una aplicación Python usando Docker, necesitarás crear una imagen Docker. Una imagen Docker es un paquete ligero, autónomo y ejecutable que incluye todo lo necesario para ejecutar la aplicación, incluyendo el código, el entorno de ejecución, las herramientas del sistema y las bibliotecas.

Aquí hay un ejemplo de cómo crear una imagen Docker para una simple aplicación Python:

Crea un nuevo directorio para tu proyecto y navega a él en tu terminal.

Crea un nuevo archivo llamado app.py y añade el siguiente código Python:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, LabEx!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Crea un nuevo archivo llamado Dockerfile y añade el siguiente contenido:
```
FROM python:3.9-slim
WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir -r requirements.txt
CMD ["python", "app.py"]
```
Este Dockerfile define los pasos para construir la imagen Docker para tu aplicación Python. Comienza con la imagen base python:3.9-slim, establece el directorio de trabajo en /app, copia los archivos de la aplicación al contenedor, instala las dependencias necesarias y ejecuta el script app.py.
Crea un nuevo archivo llamado requirements.txt y añade la siguiente dependencia:
```
flask
```
Construye la imagen Docker usando el siguiente comando:
```
$ docker build -t my-python-app .
```
Este comando construye la imagen Docker con la etiqueta my-python-app.

Ejecutando la Aplicación Python en un Contenedor Docker

Una vez que tengas la imagen Docker, puedes ejecutar la aplicación Python en un contenedor Docker usando el siguiente comando:

$ docker run -p 5000:5000 my-python-app

Este comando ejecuta el contenedor my-python-app, mapeando el puerto 5000 del contenedor al puerto 5000 del host.

Ahora puedes acceder a la aplicación Python abriendo un navegador web y navegando a http://localhost:5000. Deberías ver el mensaje "Hello, LabEx!" mostrado.

Implementando el Contenedor Docker

Subiendo la Imagen Docker a un Registro

Para implementar tu contenedor Docker, primero necesitarás subir la imagen Docker a un registro, como Docker Hub o un registro privado. Esto te permite compartir y distribuir tu aplicación a otros entornos.

Aquí te mostramos cómo subir tu imagen my-python-app a Docker Hub:

Crea una cuenta en Docker Hub (si aún no la tienes) en https://hub.docker.com.
Inicia sesión en Docker Hub usando el comando docker login:
```
$ docker login
```
Introduce tu nombre de usuario y contraseña de Docker Hub cuando se te solicite.
Etiqueta tu imagen local my-python-app con tu nombre de usuario de Docker Hub y una etiqueta (por ejemplo, latest):
```
$ docker tag my-python-app username/my-python-app:latest
```

Sube la imagen etiquetada a Docker Hub:

$ docker push username/my-python-app:latest

Ahora tu imagen Docker está disponible en el registro Docker Hub y puede ser extraída e implementada en otros sistemas.

Implementando el Contenedor Docker

Para implementar el contenedor Docker en un entorno de producción, puedes usar una plataforma de orquestación de contenedores como Kubernetes o Docker Swarm. Estas plataformas proporcionan funciones para escalar, equilibrar la carga y gestionar el ciclo de vida de tus contenedores.

Aquí hay un ejemplo de cómo implementar el contenedor my-python-app usando Docker Swarm:

Inicializa un clúster Docker Swarm:
```
$ docker swarm init
```
Crea un nuevo servicio para el contenedor my-python-app:
```
$ docker service create --name my-python-app -p 5000:5000 username/my-python-app:latest
```
Este comando crea un nuevo servicio llamado my-python-app y ejecuta la imagen username/my-python-app:latest, mapeando el puerto 5000 del contenedor al puerto 5000 del host.
Escala el servicio a varias réplicas:
```
$ docker service scale my-python-app=3
```
Este comando escala el servicio my-python-app a 3 réplicas, proporcionando alta disponibilidad y equilibrio de carga para la aplicación.
Monitoriza el estado del servicio:
```
$ docker service ls
$ docker service logs my-python-app
```
Estos comandos te permiten ver el estado del servicio my-python-app e inspeccionar los registros.

Al usar una plataforma de orquestación de contenedores como Docker Swarm, puedes gestionar, escalar e implementar fácilmente tus contenedores Docker en un entorno de producción.

Resumen

Al finalizar este tutorial, tendrás una comprensión sólida de Docker y la capacidad de contener tu aplicación Python. Aprenderás a construir una imagen Docker, ejecutar el contenedor y desplegar tu aplicación de forma consistente, confiable y escalable. Dominar Docker para el desarrollo de Python optimizará tu flujo de trabajo y hará que tu aplicación sea más portable y fácil de gestionar.