- 👤 Andrés Cruz

🇺🇸 In english

Ver Listado »

La Guía Maestra de Flask: Desarrollo Web con Python de Principio a Fin

En el vasto universo del desarrollo web con Python, Flask brilla como un faro de flexibilidad y poder. A diferencia de frameworks más grandes y "opinados", Flask es un microframework que te entrega el control total, proporcionando un núcleo sólido y minimalista sobre el cual puedes construir cualquier cosa, desde un simple blog hasta una compleja API RESTful o una aplicación en tiempo real. En DesarrolloLibre, hemos explorado cada faceta de Flask, y esta guía es la destilación de años de experiencia práctica.

Este SUPER post,. Es un manual completo que te llevará de la mano en cada etapa del ciclo de vida del desarrollo con Flask. Comenzaremos con la configuración de tu entorno y tu primera aplicación "Hola, Mundo". Luego, profundizaremos en los pilares del framework: el enrutamiento, el motor de plantillas Jinja2, la gestión de la configuración y las variables de entorno. Construiremos una aplicación robusta con manejo de bases de datos, autenticación de usuarios, control de acceso basado en roles, formularios seguros y notificaciones flash. Finalmente, exploraremos el ecosistema avanzado de Flask con tareas asíncronas, WebSockets, caching, testing y te mostraremos cómo desplegar tu creación en la nube. 

Prepárate para dominar Flask, una herramienta que encarna la simplicidad y el poder de Python.

Flask es un framework web estupendo para la creación de aplicaciones web del lado del servidor con Python; si no tienes conocimientos en el uso de frameworks web del servidor con Python, Flask es un buen candidato para inciar; al ser un microframework, lo que significa que inicialmente trae lo mínimo necesario para poder funcionar, puedes ir viendo de a poco cómo funciona el framework sin dar cabida a confusiones con archivos, estructura de directorios o módulos que no haz colocado, como sucede con otros frameworks más robustos como Django, que al crear un proyecto en Django, cuenta con muchos archivos y carpetas.

Aunque, que Flask sea un microframework no significa que debe ser empleado para proyectos pequeños, ya que, cuenta con una gran cantidad de extensiones que puedes configurar al proyecto en base a las necesidades del mismo; por ejemplo, si necesitas enviar emails, ya existen extensiones, al igual que si quieres realizar el login social, conectarse mediante ftp, módulos de usuarios, etc.

Flask es un microframework utilizado para el desarrollo de aplicaciones web en Python, aunque el término de microframework no te confunda ya que, lo puedes emplear para construir toda clase de aplicaciones web, tanto pequeñas como grandes. 

¿Qué es Flask?

Flask es un micro framework que permite crear todo tipo de apps webs de una manera sencilla y escalable, es un framework web basado en Python y cuenta con funcionalidades típicas o que pueden ser agregadas mediante dependencias como un motor de plantilla, ORM, paquetes para manejar el usuario, etc.

Ventajas

Flask es un framework web de propósito general, así que, podemos emplearlo para desarrollar cualquier tipo de aplicación web, en base a esto, veamos sus principales características.

¿Qué es Flask?

Flask es un microframework para Python basado en Werkzeug (una librería de utilidades WSGI) y Jinja2 (un motor de plantillas). El término "micro" no significa que sea limitado; significa que su núcleo es pequeño y no impone decisiones sobre qué herramientas usar. Te da la libertad de elegir tus propias librerías para el acceso a bases de datos (ORM), validación de formularios, etc.

En mi experiencia, esta flexibilidad es su mayor fortaleza. A diferencia de frameworks monolíticos, Flask te permite construir la aplicación pieza por pieza, entendiendo cada componente que añades.

Características principales de Flask

Flask es un microframework estupendo para comenzar en el desarrollo de aplicaciones web con Python, al ser un microframework trae lo mínimo para funcionar sin preocuparnos de una estructura difícil de seguir para los primerizos como ocurre con Django, lo cual lo hace un candidato excelente para iniciar en este mundillo.

Entre las características principales de Flask tenemos:

Estas son solamente algunas de las características principales de Flask, pero, exiten muchas otras.

Al instalar Flask, se instalan varias dependencias, entre las principales tenemos:

Ventajas del Flask

  1. Fácil de entender
    Flexible
  2. Buenas herramientas de prueba.

Desventajas de Flask

  1. Al ser un microframework, cada desarrollador puede decidir por lógica propia como crecer la aplicación que está llevando a cabo, por lo tanto, puede romper con las buenas prácticas y los estándares.
  2. Django es un marco muy demandado para la creación de aplicaciones de rápido movimiento. Su primera versión se introdujo en 2005. Django tiene una gran comunidad en todo el mundo. Ha reunido numerosas extensiones, complementos y aplicaciones de terceros que cubren una amplia gama de necesidades durante su existencia. Django adopta un enfoque integral, proporcionando un panel de administración, ORM (mapeo relacional de objetos), interfaces de base de datos y estructura de directorios directamente desde el primer momento. Aplicaciones como Facebook y Pinterest lo usan con éxito.

Sección 1: Fundamentos y Configuración Inicial

Antes de poder construir aplicaciones complejas, debemos asentar una base sólida. Esta sección te guiará a través de la instalación de Flask, la configuración de tu entorno de desarrollo en Visual Studio Code, y la comprensión de los conceptos esenciales como las variables de entorno y los archivos de configuración, que son cruciales para crear aplicaciones mantenibles y seguras.

Preparar el Entorno para Desarrollar en Flask

Si estás dando tus primeros pasos en el desarrollo web con Python, Flask es el punto de partida perfecto. Su naturaleza de microframework lo hace ligero, flexible y extremadamente potente.

Instalación y Entorno Virtual

La primera regla del desarrollo en Python es: siempre usa un entorno virtual. Esto aísla las dependencias de tu proyecto y evita conflictos.

# 1. Crea y navega a la carpeta de tu proyecto
mkdir mi-app-flask && cd mi-app-flask

# 2. Crea un entorno virtual
python -m venv venv

# 3. Activa el entorno virtual
# Windows
.\venv\Scripts\activate
# macOS/Linux
source venv/bin/activate

# 4. Instala Flask
pip install Flask

Configuración en Visual Studio Code

VS Code es un editor excelente para el desarrollo con Flask. Para una experiencia óptima:

  1. Instala la extensión oficial de Python de Microsoft.
  2. Selecciona el intérprete de tu entorno virtual: Presiona Ctrl+Shift+P, busca "Python: Select Interpreter" y elige el que está dentro de tu carpeta venv.

Con esto, tu entorno está listo para que el linter, el debugger y el autocompletado funcionen correctamente con las dependencias de tu proyecto.

Sigue la guía completa de configuración en: Preparar el entorno para empezar a desarrollar aplicaciones en Flask.

"Hola Mundo" en Flask: Tu Primera Aplicación Web

Una vez configurado el entorno, crear una aplicación web funcional en Flask requiere solo unas pocas líneas de código.

Creando el Archivo Principal

Crea un archivo, por ejemplo run.py, con el siguiente contenido:

from flask import Flask

# 1. Crea una instancia de la aplicación Flask
# __name__ le dice a Flask dónde buscar recursos como plantillas y archivos estáticos.
app = Flask(__name__)

# 2. Define una ruta usando un decorador
# Esto vincula la URL raíz ("/") con la función home().
@app.route('/')
def home():
    # 3. La función de vista devuelve la respuesta que se enviará al navegador.
    return "¡Hola, Mundo desde Flask!"

# 4. (Opcional, para desarrollo) Inicia el servidor si el script se ejecuta directamente.
if __name__ == '__main__':
    app.run(debug=True)

Ejecutando la Aplicación

Puedes ejecutar la aplicación de dos maneras:

  1. Directamente con Python: python run.py. El if __name__ == '__main__': se encargará de iniciar el servidor.
  2. Con el comando flask: Primero, necesitas decirle a Flask dónde está tu aplicación a través de variables de entorno, y luego puedes usar el comando flask run.

El modo debug=True es increíblemente útil durante el desarrollo, ya que reinicia el servidor automáticamente con cada cambio y proporciona un depurador interactivo en el navegador si ocurre un error.

Crea tu primera app en minutos con nuestra guía: Hola Mundo Flask: crea tu primera app web con Python.

Variables de Entorno: .flaskenv

Las variables de entorno son cruciales para configurar el comportamiento de Flask sin modificar el código. Las dos más importantes son:

En lugar de establecerlas manualmente en la terminal cada vez, Flask puede cargarlas automáticamente desde archivos .env o .flaskenv si tienes python-dotenv instalado.

$ pip install python-dotenv

Ahora, crea un archivo llamado .flaskenv en la raíz de tu proyecto:

# .flaskenv
$ FLASK_APP=run.py
$ FLASK_ENV=development

Con este archivo, solo necesitas ejecutar flask run en tu terminal, y Flask sabrá qué hacer. Para variables sensibles (como claves de API), usa un archivo .env, que también se carga automáticamente pero no debe subirse a tu repositorio de Git.

Domina las variables de entorno en: Crear variables de entorno en Flask .flaskenv.

Archivos de Configuración para una App Escalable

A medida que tu aplicación crece, necesitarás gestionar más parámetros de configuración: la clave secreta, la URI de la base de datos, configuraciones de correo, etc. Flask permite cargar configuraciones desde un objeto, una clase o un archivo.

Una práctica recomendada es crear un archivo config.py con diferentes clases para cada entorno:

# config.py
class Config:
    SECRET_KEY = 'una-clave-secreta-muy-segura'

class DevConfig(Config):
    DEBUG = True
    SQLALCHEMY_DATABASE_URI = 'sqlite:///dev.db'

class ProdConfig(Config):
    DEBUG = False
    SQLALCHEMY_DATABASE_URI = 'postgresql://user:pass@host/db'

Luego, en el archivo principal de tu aplicación, puedes cargar la configuración deseada:

from flask import Flask
import config

app = Flask(__name__)
app.config.from_object(config.DevConfig) # Carga la configuración de desarrollo

Esto te permite cambiar fácilmente entre configuraciones para desarrollo, pruebas y producción sin tocar el código de la aplicación. La SECRET_KEY es especialmente importante, ya que Flask y sus extensiones la usan para firmar criptográficamente cookies de sesión y otros datos de seguridad.

Aprende a estructurar tus configuraciones en: Manejo de parámetros de configuraciones en Flask.

Sección 2: Construcción de la Aplicación Web

Con los fundamentos en su lugar, es hora de construir las características principales de nuestra aplicación web. Esta sección cubre el sistema de enrutamiento de Flask para definir las URLs de nuestra aplicación, el uso del motor de plantillas Jinja2 para renderizar HTML dinámico, y el manejo de formularios web de manera segura y eficiente con la extensión WTForms.

Rutas y Vistas: El Corazón de una Aplicación Flask

En Flask, una "ruta" es la asociación entre una URL y una "función de vista" de Python. El decorador @app.route() es el encargado de crear esta asociación.

Rutas Dinámicas

A menudo, una URL necesita aceptar una parte variable. Por ejemplo, para mostrar el perfil de un producto por su ID. Flask lo maneja elegantemente especificando el tipo de la variable en la ruta.

@app.route('/producto/<int:id>')
def ver_producto(id):
    # La variable 'id' ya ha sido convertida a un entero.
    # Aquí buscaríamos el producto en la base de datos con ese id.
    return f"Mostrando el producto con ID: {id}"

Puedes usar conversores como string (por defecto), int, float, y path.

Métodos HTTP

Por defecto, una ruta solo responde a peticiones GET. Para manejar otros métodos como POST (para enviar formularios), debes especificarlos en el decorador.

from flask import request

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        # Procesar los datos del formulario de login
        return "Procesando login..."
    else:
        # Mostrar el formulario de login
        return "Este es el formulario de login."

En Flask 2.0 y superior, puedes usar decoradores de atajo más legibles: @app.get('/path') y @app.post('/path').

Domina el sistema de rutas en: Rutas en Flask.

Motor de Plantillas con Jinja2

Rara vez querrás devolver texto plano. Flask se integra con el motor de plantillas Jinja2 para renderizar HTML dinámico.

Para usarlo, necesitas una carpeta llamada templates en la raíz de tu proyecto. La función render_template() buscará los archivos HTML allí.

from flask import render_template

@app.route('/saludo/<string:nombre>')
def saludo(nombre):
    # Pasamos la variable 'nombre' al contexto de la plantilla.
    return render_template('saludo.html', nombre=nombre)

Dentro de templates/saludo.html, puedes usar la sintaxis de Jinja2:

<h1>Hola, {{ nombre }}!</h1>

Estructuras de Control y Herencia de Plantillas

Jinja2 es un motor de plantillas completo. Soporta bucles, condicionales y, lo más importante, herencia de plantillas. Esto te permite crear una plantilla base (base.html) con la estructura común (head, navbar, footer) y hacer que otras plantillas la extiendan.

<!-- templates/base.html -->
<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <div id="content">
        {% block content %}{% endblock %}
    </div>
</body>
</html>

<!-- templates/hijo.html -->
{% extends "base.html" %}

{% block title %}Página Hija{% endblock %}

{% block content %}
    <h1>Este es el contenido de la página hija.</h1>
{% endblock %}

Además, puedes crear macros para generar fragmentos de HTML reutilizables, como un componente de paginación.

Aprende todo sobre Jinja2 en: Jinja2 en Flask 3 y crea un macro de paginación.

Formularios Seguros y Validados con WTForms

Manejar formularios HTML directamente es tedioso y propenso a errores. La extensión Flask-WTF se integra con la librería WTForms para proporcionar una solución de alto nivel para:

El proceso implica definir una clase de formulario que hereda de FlaskForm.

from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email

class LoginForm(FlaskForm):
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired()])
    submit = SubmitField('Iniciar Sesión')

En tu función de vista, creas una instancia del formulario y manejas la validación.

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        # Los datos son válidos. Procesa el login.
        # form.email.data y form.password.data contienen los valores.
        flash(f'Login solicitado para el usuario {form.email.data}')
        return redirect(url_for('home'))
    # Si la petición es GET o la validación falla, renderiza la plantilla con el formulario.
    return render_template('login.html', form=form)

En la plantilla, puedes renderizar los campos, incluyendo las etiquetas y los mensajes de error. Flask-WTF también se encarga de añadir un token CSRF oculto para la seguridad.

Construye formularios robustos con: Formularios WTForms en Flask 3.

Sección 3: Autenticación y Gestión de Usuarios

Casi todas las aplicaciones web necesitan una forma de identificar a sus usuarios. Esta sección te guiará a través de la implementación de un sistema completo de autenticación y autorización en Flask, desde el manejo de datos de sesión y la autenticación de usuarios, hasta la creación de un sistema de control de acceso basado en roles.

Sesión en Flask: Almacenando Datos del Usuario

HTTP es un protocolo sin estado (stateless), lo que significa que cada petición es independiente. Para recordar quién es un usuario entre peticiones, necesitamos un mecanismo de sesión. Flask proporciona un objeto session que funciona como un diccionario. Puedes guardar datos en él, y estarán disponibles en las siguientes peticiones del mismo usuario.

Por defecto, Flask utiliza cookies seguras (firmadas criptográficamente) para almacenar los datos de la sesión en el lado del cliente. Por eso es crucial establecer una SECRET_KEY fuerte en tu configuración.

from flask import session, redirect, url_for

@app.route('/set_user/<name>')
def set_user(name):
    session['username'] = name
    return 'Usuario guardado en la sesión.'

@app.route('/get_user')
def get_user():
    return session.get('username', 'No hay usuario en la sesión.')

@app.route('/logout')
def logout():
    session.pop('username', None) # Elimina el usuario de la sesión
    return redirect(url_for('home'))

La sesión es la base sobre la cual construiremos nuestro sistema de autenticación.

Entiende cómo funciona la sesión en: Sesión en Flask: cómo almacenar y gestionar datos del usuario.

Autenticación de Usuarios con Flask-Login

La extensión Flask-Login simplifica enormemente la gestión de sesiones de usuario. Se encarga de iniciar y cerrar sesión, recordar usuarios entre sesiones y proteger vistas para que solo los usuarios autenticados puedan acceder.

Configuración de Flask-Login

El proceso requiere varios pasos:

  1. Inicializar la extensión: login_manager = LoginManager(app)
  2. Crear un modelo de Usuario: Tu modelo de usuario (por ejemplo, de SQLAlchemy) debe heredar de UserMixin, que proporciona las implementaciones por defecto que Flask-Login necesita.
  3. Crear un user_loader: Debes proporcionar una función decorada con @login_manager.user_loader que le diga a Flask-Login cómo cargar un usuario a partir de su ID, que se almacena en la sesión.
from flask_login import UserMixin, login_user, logout_user, login_required, current_user

class User(UserMixin, db.Model):
    # ... tus campos ...

@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))

Inicio y Cierre de Sesión

En tu vista de login, después de validar las credenciales del usuario, llamas a login_user().

@app.route('/login', methods=['GET', 'POST'])
def login():
    # ... validación del formulario ...
    user = User.query.filter_by(email=form.email.data).first()
    if user and user.check_password(form.password.data):
        login_user(user, remember=form.remember_me.data)
        return redirect(url_for('dashboard'))
    # ...

Para cerrar sesión, simplemente llamas a logout_user().

Protección de Vistas y current_user

Para proteger una ruta, solo tienes que añadir el decorador @login_required. Si un usuario no autenticado intenta acceder, Flask-Login lo redirigirá a la página de login.

Dentro de cualquier vista, puedes acceder al usuario actualmente autenticado a través del proxy current_user.

from flask_login import login_required, current_user

@app.route('/dashboard')
@login_required
def dashboard():
    return f"¡Bienvenido a tu dashboard, {current_user.username}!"

Implementa un sistema de login completo con: Cómo implementar autenticación de usuarios con Flask-Login.

Control de Acceso Basado en Roles (RBAC)

La autenticación responde a la pregunta "¿quién eres?", mientras que la autorización responde a "¿qué tienes permitido hacer?". Un sistema de roles es la forma más común de implementar la autorización.

El proceso implica extender tu base de datos para incluir modelos de Role y una tabla de asociación para manejar una relación de muchos a muchos entre usuarios y roles.

roles_users = db.Table('roles_users',
    db.Column('user_id', db.Integer(), db.ForeignKey('users.id')),
    db.Column('role_id', db.Integer(), db.ForeignKey('roles.id'))
)

class Role(db.Model):
    # ...

class User(UserMixin, db.Model):
    # ...
    roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))

    def has_role(self, role_name):
        return any(role.name == role_name for role in self.roles)

Creando un Decorador de Permisos

Para proteger rutas para roles específicos (ej. 'admin'), podemos crear nuestro propio decorador.

from functools import wraps
from flask import abort

def role_required(role_name):
    def decorator(f):
        @wraps(f)
        def decorated_function(*args, **kwargs):
            if not current_user.is_authenticated or not current_user.has_role(role_name):
                abort(403) # Forbidden
            return f(*args, **kwargs)
        return decorated_function
    return decorator

@app.route('/admin')
@login_required
@role_required('admin')
def admin_dashboard():
    return "Bienvenido al panel de administrador."

Este sistema te da un control granular sobre quién puede acceder a qué partes de tu aplicación.

Añade un sistema de roles y permisos con: Cómo implementar el control de acceso basado en roles en Flask.

Sección 4: Temas Avanzados y Ecosistema Flask

Una vez que dominas los fundamentos, el ecosistema de Flask te abre un mundo de posibilidades para construir aplicaciones más potentes, interactivas y eficientes. En esta sección, exploraremos cómo crear APIs RESTful, habilitar la comunicación en tiempo real con WebSockets, optimizar el rendimiento con tareas en segundo plano y caching, y asegurar la calidad de tu código con pruebas automatizadas.

Creación de APIs RESTful

Flask es una herramienta excepcional para construir APIs RESTful gracias a su simplicidad. Una API REST permite que diferentes sistemas (como una aplicación móvil o un frontend en JavaScript) se comuniquen con tu backend a través de HTTP.

El principio es el mismo que con las vistas web, pero en lugar de devolver HTML con render_template, devuelves datos en formato JSON usando la función jsonify.

from flask import jsonify

@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    tasks = Task.query.all()
    return jsonify([task.to_dict() for task in tasks])

@app.route('/api/tasks', methods=['POST'])
def create_task():
    # ... lógica para crear la tarea a partir de request.json ...
    return jsonify(new_task.to_dict()), 201 # 201 Created

Habilitando CORS para tu API

Si tu API va a ser consumida por un frontend que vive en un dominio diferente, te toparás con errores de CORS (Cross-Origin Resource Sharing). El navegador, por seguridad, bloquea estas peticiones. La extensión Flask-CORS resuelve esto añadiendo las cabeceras HTTP necesarias.

$ pip install Flask-Cors
from flask_cors import CORS

app = Flask(__name__)
# Habilita CORS para todas las rutas y orígenes
CORS(app)

Para producción, puedes configurarlo para permitir solo orígenes específicos.

Construye tu primera API en: Crear una Api Restful en Flask y habilita CORS.

Tareas Asíncronas en Segundo Plano con Celery

Algunas tareas toman demasiado tiempo para ejecutarse dentro de una petición HTTP, como enviar un correo electrónico, procesar una imagen o generar un reporte. Si lo haces en la vista, el usuario tendrá que esperar hasta que la tarea termine, lo que resulta en una mala experiencia.

Celery es una cola de tareas distribuida que te permite ejecutar estas tareas de forma asíncrona en un proceso separado ("worker").

El flujo es:

  1. Una vista de Flask recibe una petición.
  2. En lugar de ejecutar la tarea pesada directamente, la "envía" a la cola de Celery con .delay().
  3. La vista devuelve una respuesta inmediata al usuario.
  4. Un proceso "worker" de Celery, que corre en segundo plano, recoge la tarea de la cola y la ejecuta.

Esto es indispensable para la escalabilidad y la capacidad de respuesta de tu aplicación.

Descubre cuándo y por qué usar Celery en: 4 casos de uso sobre cuándo usar Celery en una aplicación en Flask.

Comunicación en Tiempo Real con Flask-SocketIO

Para aplicaciones que requieren comunicación bidireccional instantánea, como chats o notificaciones en tiempo real, el modelo de petición-respuesta de HTTP no es suficiente. Aquí es donde entran los WebSockets.

La extensión Flask-SocketIO integra el protocolo Socket.IO en tu aplicación Flask, permitiendo una comunicación persistente y full-duplex entre el cliente y el servidor.

Puedes definir "eventos" y "habitaciones" (rooms) para enviar mensajes a clientes específicos.

from flask_socketio import SocketIO, emit, join_room

app = Flask(__name__)
socketio = SocketIO(app)

@socketio.on('join')
def on_join(data):
    room = data['room']
    join_room(room)
    emit('status', {'msg': 'Se ha unido a la sala.'}, to=room)

@socketio.on('chat_message')
def handle_message(data):
    room = data['room']
    # Envía el mensaje a todos en la misma sala
    emit('new_message', data['message'], to=room)

Esto te permite construir aplicaciones altamente interactivas sin que el cliente tenga que estar constantemente preguntando ("polling") al servidor si hay nuevos datos.

Crea tu primera aplicación en tiempo real con: Cómo usar Flask-SocketIO.

Pruebas Unitarias con Pytest

Escribir pruebas automatizadas es una práctica fundamental para asegurar que tu aplicación funciona correctamente y para evitar regresiones. Pytest es un framework de testing para Python que hace que escribir pruebas sea simple y legible.

Flask se integra bien con Pytest. Puedes crear un "fixture" para configurar un cliente de prueba que realice peticiones a tu aplicación sin necesidad de un servidor web real.

# tests/conftest.py
import pytest
from my_app import create_app

@pytest.fixture
def client():
    app = create_app('testing')
    with app.test_client() as client:
        with app.app_context():
            # Aquí podrías inicializar la base de datos de prueba
            pass
        yield client

# tests/test_main.py
def test_home_page(client):
    """Prueba que la página de inicio se carga correctamente."""
    response = client.get('/')
    assert response.status_code == 200
    assert b"Bienvenido" in response.data

Las pruebas te dan la confianza para refactorizar y añadir nuevas características sin miedo a romper lo que ya funciona.

Aprende a configurar tu suite de pruebas en: Pruebas Unitarias en Flask con Pytest.

Sección 5: Despliegue

Una vez que tu aplicación está construida y probada, el último paso es ponerla en línea para que el mundo la pueda usar. El despliegue (deployment) puede parecer intimidante, pero las plataformas modernas como Railway lo han simplificado enormemente, permitiéndote pasar del código en tu máquina a una aplicación en vivo en cuestión de minutos.

Despliegue de un Proyecto Flask en Railway

Railway es una plataforma de infraestructura en la nube que automatiza gran parte del proceso de despliegue. Funciona conectándose a tu repositorio de GitHub y desplegando tu aplicación cada vez que haces un push a tu rama principal.

Preparación del Proyecto para Despliegue

Antes de desplegar, necesitas tres archivos clave en tu repositorio:

  1. requirements.txt: Una lista de todas las dependencias de Python de tu proyecto. Se genera con pip freeze > requirements.txt. Railway lo usará para instalar todo lo necesario.
  2. Procfile: Un archivo de texto sin extensión que le dice a Railway cómo ejecutar tu aplicación. Para una aplicación Flask, necesitas un servidor WSGI de producción como Gunicorn.
# Procfile
web: gunicorn --bind 0.0.0.0:$PORT run:app

(Asegúrate de tener gunicorn en tu requirements.txt).

  1. runtime.txt (Opcional pero recomendado): Especifica la versión de Python a usar.
# runtime.txt
python-3.11.4

Proceso de Despliegue en Railway

  1. Crea una cuenta en Railway y conecta tu GitHub.
  2. Crea un Nuevo Proyecto: Selecciona "Deploy from GitHub repo" y elige tu repositorio de Flask.
  3. Aprovisiona una Base de Datos: Si tu aplicación necesita una base de datos, puedes añadir un servicio de PostgreSQL o MySQL con un solo clic desde el panel de Railway.
  4. Configura las Variables de Entorno: Railway detectará las variables de tu base de datos y las inyectará en tu aplicación. Debes añadir manualmente cualquier otra variable que necesites, como tu SECRET_KEY o claves de API de terceros.
  5. ¡Despliega! Railway detectará tu Procfile y requirements.txt, construirá tu aplicación y la desplegará. En minutos, te proporcionará una URL pública donde tu aplicación estará en vivo.

Plataformas como Railway democratizan el despliegue, permitiendo a los desarrolladores centrarse en el código y no en la complejidad de la infraestructura.

Sigue nuestra guía paso a paso para desplegar tu aplicación en: Deploy de un proyecto en Flask o FastAPI en Railway.

Soporte, versiones y nuevas caracteristicas

Para usar Flask 3 que es la última versión lanzada a finales de 2024, es necesario emplear Python 3.9 o superior y Flask a incorpora nuevas características desde la version 1 como decoradores de ruta más legibles y cortos para métodos HTTP comunes.

Por ejemplo:

@app.route ("/ auth", métodos = ["POST"]

Ahora también se puede escribir como:

@app.post ("/ auth")

Soporte de espera asíncrono inicial (matraz de instalación opcional [asíncrono]), que permite manejadores de rutas asíncronas, manejadores de errores, solicitudes asíncronas Aquí hay un ejemplo:

@app.route("/get-data")
async def get_data():
  data = await async_db_query(...)
  return jsonify(data)

Y como es común, muchas depreciaciones. Así que no se alarme cuando vea muchas advertencias de obsolescencia cuando ejecute el servidor Flask en versiones modernas lo cual es típico en frameworks de Python.

Curso y Libro para dominar Flask 3

Recuerda que en este blog, tienes cursos y libros COMPLETOS para que domines Flask, todos los posts mencionados antes, son sacados del curso y libro; puedes adquirirlos desde el apartado de Cursos y Libros en el menú.

Conclusión: El Poder de la Simplicidad de Flask

A lo largo de esta guía, hemos viajado desde los conceptos más básicos de Flask hasta la construcción y despliegue de una aplicación web completa y robusta. Hemos visto cómo la filosofía de microframework de Flask, lejos de ser una limitación, es su mayor fortaleza. Te otorga la libertad de elegir tus herramientas, estructurar tu proyecto como desees y construir exactamente la aplicación que necesitas, sin el peso de componentes innecesarios.

Hemos aprendido a manejar rutas, renderizar plantillas dinámicas, gestionar bases de datos, implementar sistemas de autenticación seguros, y explorar el vibrante ecosistema de extensiones que permiten desde comunicación en tiempo real hasta la ejecución de tareas en segundo plano. Finalmente, hemos visto lo sencillo que puede ser llevar nuestra creación a producción con las plataformas en la nube modernas.

Flask demuestra que no se necesita un framework masivo para construir aplicaciones potentes. Con un núcleo simple, una comunidad fuerte y un ecosistema de extensiones maduro, Flask se mantiene como una de las opciones más elegantes y productivas para el desarrollo web con Python. Esperamos que esta guía te sirva como un recurso confiable en tu viaje como desarrollador de Flask. Ahora, ¡a construir!

Ver Listado »

Su experiencia en este sitio será mejorada con el uso de cookies.