Rutas en Flask

▶

Ya que conocemos como definir un Hola Mundo Flask, lo siguiente que necesitamos conocer es como crear rutas, en Flask, no necesitamos configurar un archivo aparte de configuraciones, como ocurre con Laravel con el web.php; es simplemente un decorador. En este artículo te mostraré cómo funcionan las rutas en Flask, cómo crear rutas dinámicas, usar distintos métodos HTTP y organizar tu aplicación de forma profesional.

¿Qué es una ruta en Flask y cómo funciona?

En Flask, una ruta es el vínculo entre una URL y una función que se ejecuta cuando un usuario visita esa dirección. Dicho de otro modo: cada vez que alguien accede a /productos, Flask busca qué función debe ejecutarse para responder.

El corazón de todo está en el decorador @app.route(), que le dice al framework qué URL debe asociar con cada función:

from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
   return "Bienvenido a mi aplicación Flask"

Cada vez que Flask recibe una solicitud (request), pasa por un flujo sencillo:

• Detecta la ruta solicitada.
• Busca la función asociada.
• Genera una respuesta (response) y la envía al navegador.

Rutas dinámicas y variables en la URL

Muchas veces necesitamos que una ruta acepte variables. Por ejemplo, para mostrar el perfil de un usuario según su ID:

@app.route('/usuario/<int:id>')
def usuario(id):
   return f"Perfil del usuario {id}"

Y si, todo en Flask es pequeño al ser un microframework pero, completamente funcional.

Flask usa los llamados converters, que definen el tipo de dato que se espera:

• string: valor por defecto.
• int: números enteros.
• float: decimales.
• path: texto con /.
• uuid: identificador universal.

También puedes tener variables opcionales o múltiples parámetros en una misma URL:

@app.route('/producto/<categoria>/<int:id>')
def producto(categoria, id):
   return f"{categoria.capitalize()} - ID {id}"

Métodos HTTP y manejadores de rutas

Existen distintos métodos HTTP que podemos usar para realizar peticiones al servidor; estos métodos no son más que un conjunto de verbos que se utilizan para realizar diferentes tipos de acciones; los métodos más comunes son GET, POST, PUT, PATCH y DELETE:

• GET: se utiliza para obtener información de un servidor web. La información se envía en la URL de la petición.
• POST: se utiliza para enviar información a un servidor web. La información se envía en el cuerpo de la petición.
• PUT: se utiliza para actualizar información en un servidor web. La información se envía en el cuerpo de la petición.
• PATCH: se utiliza para actualizar parcialmente información en un servidor web. La información se envía en el cuerpo de la petición.
• DELETE: se utiliza para eliminar información de un servidor web. La información se envía en la URL de la petición.

Todos estos métodos tienen su equivalente en Flask; de momento hemos utilizado métodos de tipo GET, para obtener datos, pero, también es posible emplear otros:

@app.route(<URI>, methods=('GET'))
@app.route(<URI>, methods=('POST'))
@app.route(<URI>, methods=('PUT'))
@app.route(<URI>, methods=('PATCH'))
@app.route(<URI>, methods=('DELETE'))

Puedes indicar varios que más de un método sea resuelto por un mismo controlador:

@app.route(<URI>, methods=('GET', 'POST'))

Como puedes ver, tenemos una función decoradora para cada tipo de método y tiene una relación directa con el tipo de petición HTTP.

En Flask, puedes definir qué métodos acepta cada ruta:

@app.route('/formulario', methods=('GET', 'POST'))
def formulario():
   if request.method == 'POST':
       nombre = request.form['nombre']
       return f"Hola {nombre}!"
   return render_template('formulario.html')

Usualmente se emplean métodos de tipo GET y POST cuando una misma ruta muestra un formulario y procesa los datos enviados. Esto evita duplicar vistas y mantiene el código más limpio.

Para APIs REST, también puedes usar PUT, PATCH y DELETE en tus controladores.

URL building y la función url_for()

En lugar de escribir las URLs a mano, Flask ofrece la función url_for() para construirlas dinámicamente:

from flask import url_for
@app.route('/dashboard')
def dashboard():
   return "Panel de control"
# En otra parte
url_for('dashboard')  # Devuelve '/dashboard'

Ventajas:

• Si cambias el nombre de la ruta, url_for se actualiza automáticamente.
• Mejora la mantenibilidad del proyecto.
• Evita errores de rutas duplicadas.

También puedes usarlo para archivos estáticos:

<link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }

Blueprints y organización avanzada de rutas

A medida que tu aplicación crece, agrupar todas las rutas en un solo archivo se vuelve inmanejable.
Ahí entran los Blueprints, que permiten modularizar tu app:

# usuarios.py
from flask import Blueprint
usuarios_bp = Blueprint('usuarios', __name__)
@usuarios_bp.route('/perfil')
def perfil():
   return "Perfil de usuario
# app.py
from usuarios import usuarios_bp
app.register_blueprint(usuarios_bp, url_prefix='/usuarios')

De esta forma, puedes tener rutas separadas por áreas: usuarios, admin, productos, etc.
Esto no solo mejora la organización, sino también la escalabilidad.

Ejemplo completo: mini CRUD en Flask con rutas REST

Para ver todo en acción, construyamos un pequeño ejemplo con CRUD:

@app.route('/items', methods=['GET'])
def listar_items():
   return jsonify(items)
@app.route('/items', methods=['POST'])
def crear_item():
   nuevo = request.json
   items.append(nuevo)
   return jsonify(nuevo), 201
@app.route('/items/<int:id>', methods=['PUT'])
def actualizar_item(id):
   items[id].update(request.json)
   return jsonify(items[id])
@app.route('/items/<int:id>', methods=['DELETE'])
def eliminar_item(id):
   items.pop(id)
   return '', 204

Buenas prácticas de seguridad y rendimiento

• Escapa las variables en las plantillas ({{ variable | safe }}).
• Valida siempre la entrada del usuario, especialmente si viene de formularios o JSON externos.
• Usa sesiones seguras (session con claves secretas).
• En producción, combina Flask con Gunicorn + Nginx para un mejor rendimiento.

Preguntas frecuentes sobre rutas en Flask (FAQ)

¿Por qué mi ruta no funciona o da 404?
Probablemente haya un error de sintaxis o un conflicto con otra ruta. Usa flask routes para listar todas.

¿Cómo usar GET y POST en la misma ruta?
Define methods=('GET','POST') y verifica if request.method == 'POST'.

¿Qué diferencia hay entre @app.route y Blueprints?
@app.route se usa directamente en la app principal; Blueprints agrupan rutas en módulos reutilizables.

¿Por qué Flask redirige con una barra final?
Porque interpreta /ruta/ como un “directorio” y /ruta como una “acción”. Flask redirige automáticamente por consistencia.

¿Cómo probar mis rutas sin ejecutar el servidor?
Con test_request_context o el cliente de pruebas integrado de Flask y pytest.

✅ Conclusión

Las rutas en Flask son el corazón de cualquier aplicación: simples de definir, pero poderosas si se usan correctamente.
Con un poco de práctica —y prestando atención a los detalles como los métodos HTTP, los Blueprints y las pruebas— podrás construir desde pequeños formularios hasta APIs robustas.

Entender cómo Flask gestiona los métodos y el enrutamiento me permitió desarrollar apps limpias, organizadas y fáciles de mantener.

El siguiente paso que debes conocer es como crear variables de entorno mediante .env.