Exponer un servidor web Flask en Docker

Introducción

En este tutorial, exploraremos cómo exponer un servidor web Flask que se ejecuta dentro de un contenedor Docker. Al final de esta guía, aprenderás a construir una aplicación Flask, empaquetarla en un contenedor Docker y hacerla accesible desde el exterior. Ya seas un desarrollador web o un ingeniero DevOps, este tutorial te proporcionará los conocimientos necesarios para aprovechar Docker en tus proyectos basados en Flask.

Introducción a Docker y Flask

¿Qué es Docker?

Docker es una plataforma de código abierto que permite a los desarrolladores construir, desplegar y ejecutar aplicaciones en un entorno consistente y aislado llamado contenedores. Los contenedores empaquetan una aplicación y todas sus dependencias en una sola unidad portátil, garantizando que la aplicación se ejecutará de la misma manera independientemente de la infraestructura subyacente.

¿Qué es Flask?

Flask es un framework web ligero y de código abierto para Python. Está diseñado para ser fácil de usar y comenzar, lo que lo convierte en una opción popular para construir aplicaciones web, APIs y microservicios. Flask proporciona una forma simple y flexible de crear aplicaciones web, manejando tareas como el enrutamiento, el manejo de solicitudes HTTP y la representación de plantillas.

¿Por qué usar Docker con Flask?

Combinar Docker y Flask ofrece varios beneficios:

Despliegue consistente: Los contenedores Docker garantizan que la aplicación Flask y sus dependencias se empaquetan juntas, lo que facilita el despliegue consistente de la aplicación en diferentes entornos (por ejemplo, desarrollo, preproducción, producción).
Escalabilidad: La contenedorización de Docker facilita la escalabilidad de la aplicación Flask ejecutando múltiples instancias del contenedor, permitiéndole manejar un mayor tráfico y carga.
Aislamiento: Los contenedores Docker proporcionan un nivel de aislamiento, asegurando que la aplicación Flask y sus dependencias estén aisladas del sistema host y de otras aplicaciones, reduciendo el riesgo de conflictos y haciendo que la aplicación sea más segura.
Portabilidad: Los contenedores Docker se pueden compartir y mover fácilmente entre diferentes plataformas y entornos, lo que facilita el desarrollo, las pruebas y el despliegue de la aplicación Flask.

Configurando el Entorno de Desarrollo

Para comenzar con Docker y Flask, necesitarás tener lo siguiente instalado en tu sistema:

Docker: Puedes descargar e instalar Docker desde el sitio web oficial (https://www.docker.com/get-started).
Python: Flask es un framework web de Python, por lo que necesitarás tener Python instalado en tu sistema. Puedes descargar Python desde el sitio web oficial (https://www.python.org/downloads/).

Una vez que tengas Docker y Python instalados, puedes comenzar a construir tu aplicación Flask y desplegarla en un contenedor Docker.

graph TD
    A[Instalar Docker] --> B[Instalar Python]
    B --> C[Construir la Aplicación Flask]
    C --> D[Desplegar Flask en el Contenedor Docker]

Creación de una Aplicación Web Flask

Creando una Aplicación Flask

Para crear una aplicación web Flask, sigue estos pasos:

Instalar Flask: Abre una terminal y ejecuta el siguiente comando para instalar Flask:
```
pip install flask
```
Crear una Aplicación Flask: Crea un nuevo archivo Python (por ejemplo, app.py) y añade el siguiente código:
```
from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return '¡Hola, LabEx!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
```
Este código crea una aplicación Flask básica con una única ruta (/) que devuelve el mensaje "¡Hola, LabEx!".
Ejecutar la Aplicación Flask: En la terminal, navega al directorio que contiene el archivo app.py y ejecuta el siguiente comando:
```
python app.py
```
Esto iniciará el servidor de desarrollo de Flask y hará que tu aplicación esté disponible en http://localhost:5000/.

Añadiendo Rutas y Vistas

Para añadir más funcionalidad a tu aplicación Flask, puedes crear rutas y vistas adicionales:

from flask import Flask, render_template, request

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/about')
def about():
    return render_template('about.html')

@app.route('/contact', methods=['GET', 'POST'])
def contact():
    if request.method == 'POST':
        ## Manejar la presentación del formulario
        return '¡Formulario enviado con éxito!'
    return render_template('contact.html')

En este ejemplo, hemos añadido tres rutas: / (la página de inicio), /about (una página de información) y /contact (un formulario de contacto). La ruta del formulario de contacto maneja solicitudes GET y POST, permitiendo a los usuarios ver el formulario y enviarlo.

Renderizando Plantillas

Flask utiliza el motor de plantillas Jinja2 para renderizar plantillas HTML. Crea un directorio templates en tu proyecto y añade los siguientes archivos:

index.html:

<!doctype html>
<html>
  <head>
    <title>Aplicación Flask de LabEx</title>
  </head>
  <body>
    <h1>¡Bienvenido a la Aplicación Flask de LabEx!</h1>
    <p>Esta es la página de inicio.</p>
  </body>
</html>

about.html:

<!doctype html>
<html>
  <head>
    <title>Acerca de - Aplicación Flask de LabEx</title>
  </head>
  <body>
    <h1>Acerca de la Aplicación Flask de LabEx</h1>
    <p>Esta es la página de información.</p>
  </body>
</html>

contact.html:

<!doctype html>
<html>
  <head>
    <title>Contacto - Aplicación Flask de LabEx</title>
  </head>
  <body>
    <h1>Contáctanos</h1>
    <form method="post">
      <label for="name">Nombre:</label>
      <input type="text" id="name" name="name" /><br />

      <label for="email">Correo electrónico:</label>
      <input type="email" id="email" name="email" /><br />

      <label for="message">Mensaje:</label>
      <textarea id="message" name="message"></textarea><br />

      <input type="submit" value="Enviar" />
    </form>
  </body>
</html>

Estas plantillas proporcionan una estructura básica para las páginas de tu aplicación Flask.

Desplegando Flask en un Contenedor Docker

Creando un Dockerfile

Para desplegar tu aplicación Flask en un contenedor Docker, necesitarás crear un Dockerfile. Un Dockerfile es un archivo de texto que contiene instrucciones para construir una imagen Docker.

Aquí hay un ejemplo de Dockerfile para tu aplicación Flask:

## Usa la imagen oficial de Python como imagen base
FROM python:3.9-slim

## Establece el directorio de trabajo en /app
WORKDIR /app

## Copia el archivo requirements.txt en el contenedor
COPY requirements.txt .

## Instala las dependencias de Python
RUN pip install --no-cache-dir -r requirements.txt

## Copia el código de la aplicación Flask en el contenedor
COPY . .

## Exponer el puerto en el que se ejecutará la aplicación Flask
EXPOSE 5000

## Establece el comando para iniciar la aplicación Flask
CMD ["python", "app.py"]

Este Dockerfile realiza lo siguiente:

Utiliza la imagen oficial de Python 3.9 slim como imagen base.
Establece el directorio de trabajo en /app.
Copia el archivo requirements.txt en el contenedor.
Instala las dependencias de Python listadas en el archivo requirements.txt.
Copia el código de la aplicación Flask en el contenedor.
Expone el puerto 5000, que es el puerto predeterminado para el servidor de desarrollo de Flask.
Establece el comando para iniciar la aplicación Flask.

Construyendo y Ejecutando la Imagen Docker

Para construir la imagen Docker, ejecuta el siguiente comando en el mismo directorio que tu Dockerfile:

docker build -t labex-flask-app .

Esto creará una imagen Docker llamada labex-flask-app basada en las instrucciones del Dockerfile.

Para ejecutar el contenedor Docker, utiliza el siguiente comando:

docker run -p 5000:5000 labex-flask-app

Esto iniciará el contenedor Docker y mapeará el puerto 5000 del host al puerto 5000 en el contenedor, permitiéndote acceder a la aplicación Flask en http://localhost:5000/.

Escalando y Administrando el Contenedor Docker

Una vez que hayas desplegado tu aplicación Flask en un contenedor Docker, puedes aprovechar las características de escalabilidad y administración de Docker:

Escalabilidad: Puedes escalar fácilmente tu aplicación Flask ejecutando múltiples instancias del contenedor Docker, ya sea manualmente o utilizando herramientas de orquestación de contenedores como Docker Compose o Kubernetes.
Monitoreo: Docker proporciona herramientas integradas e integraciones para monitorear el estado y el rendimiento de tus contenedores, facilitando la administración de tu aplicación Flask en producción.
Versionado y Retrocesos: El enfoque basado en imágenes de Docker facilita la versión de tu aplicación Flask y la realización de retrocesos si es necesario, asegurando un proceso de despliegue más confiable y estable.

Al aprovechar Docker, puedes garantizar que tu aplicación Flask se despliegue y administre de forma consistente en diferentes entornos, simplificando el ciclo de vida de desarrollo, pruebas y producción.

Resumen

En este tutorial, has aprendido a exponer un servidor web Flask que se ejecuta dentro de un contenedor Docker. Al empaquetar tu aplicación Flask en un contenedor Docker, puedes garantizar un despliegue consistente y confiable en diferentes entornos. Con los conocimientos adquiridos, ahora puedes aprovechar el poder de Docker para optimizar tus procesos de desarrollo y despliegue de aplicaciones web Flask.

Cómo exponer un servidor web Flask en un contenedor Docker