Flask: API REST

La creación de una API REST con Flask en Python permite desarrollar servicios web ligeros y eficientes. El enfoque CRUD (Crear, Leer, Actualizar, Eliminar) define la interacción básica con recursos, estableciendo la base para el intercambio de datos en múltiples entornos y dispositivos.

Preparación del entorno

Para iniciar, se recomienda disponer de Python 3.6 o superior. Luego, en un entorno virtual activo, se instalan Flask y las dependencias que permitan diseñar la API REST:

pip install flask

Si la aplicación requiere persistencia de datos, también es frecuente incluir flask-sqlalchemy y, opcionalmente, un paquete de validación como marshmallow.

Estructura básica de la aplicación

Si en el archivo app.py definimos la aplicación principal, podemos empezar de manera sencilla:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/')
def inicio():
    return "API Flask activa"

if __name__ == '__main__':
    app.run(debug=True)

De esta forma, se cuenta con un endpoint raíz que confirma la ejecución de la aplicación de Flask. El modo debug=True sólo se recomienda para desarrollo, no para entornos productivos.

Creación de rutas para CRUD

Las rutas HTTP se organizan en función de los recursos que se manipulan. A modo de ejemplo, imaginemos un recurso llamado Usuario. Se pueden crear rutas para crear, leer, actualizar y eliminar datos.

Crear (POST)

@app.route('/usuarios', methods=['POST'])
def crear_usuario():
    datos = request.get_json()
    # Lógica para insertar en la base de datos
    # Por ejemplo: nuevo_id = insertar_usuario(datos)
    return jsonify({"mensaje": "Usuario creado"}), 201

• Se recibe la información a través de un POST, extrayendo un JSON del cuerpo de la petición.
• Se realiza la inserción en la base de datos o la lógica correspondiente.
• Se devuelve un código de estado 201 (Created) junto a un mensaje de confirmación.

Leer (GET)

@app.route('/usuarios', methods=['GET'])
def listar_usuarios():
    # Lógica para obtener todos los usuarios
    # Por ejemplo: lista = obtener_todos_los_usuarios()
    # Se devuelve un array de objetos JSON con la información
    return jsonify({"usuarios": []}), 200

Si se necesitan rutas para obtener un usuario en específico, se emplea una variable en la URL:

@app.route('/usuarios/<int:usuario_id>', methods=['GET'])
def obtener_usuario(usuario_id):
    # obtener_usuario_por_id(usuario_id)
    return jsonify({"id": usuario_id, "nombre": "Ejemplo"})

Actualizar (PUT o PATCH)

@app.route('/usuarios/<int:usuario_id>', methods=['PUT'])
def actualizar_usuario(usuario_id):
    datos = request.get_json()
    # actualizar_usuario_en_bd(usuario_id, datos)
    return jsonify({"mensaje": "Usuario actualizado"}), 200

En este método, se toma el identificador (usuario_id) de la ruta y se realizan los cambios necesarios, confirmando con un código 200 o el que se considere apropiado.

Eliminar (DELETE)

@app.route('/usuarios/<int:usuario_id>', methods=['DELETE'])
def eliminar_usuario(usuario_id):
    # eliminar_usuario_de_bd(usuario_id)
    return jsonify({"mensaje": "Usuario eliminado"}), 200

Se extrae el identificador del recurso a eliminar y se borra de la base de datos o la estructura de datos utilizada.

Manejo de datos y persistencia

En la mayoría de los casos, una API REST requiere almacenar información en una base de datos. Para ello, se suele utilizar SQLAlchemy o Flask-SQLAlchemy, definiendo modelos en clases de Python:

from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///usuarios.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

class Usuario(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(50))
    edad = db.Column(db.Integer)

# Creación de las tablas
with app.app_context():
    db.create_all()

Las funciones de CRUD usan estos modelos para añadir, leer, actualizar o eliminar entradas de la base de datos, transformando la información a JSON para enviar en la respuesta.

Validaciones y manejo de errores

Para garantizar que los datos recibidos cumplan ciertos criterios, es aconsejable integrar validaciones. Por ejemplo, se puede usar la librería marshmallow para definir esquemas y validar entradas:

pip install marshmallow

También es importante retornar códigos de estado adecuados. En caso de fallo al encontrar un usuario, se puede responder con un 404 (Not Found), y, si la información que llega está incompleta, con un 400 (Bad Request).

Respuestas en formato JSON

Las API REST suelen emplear JSON para la comunicación con clientes. En Flask, la función jsonify convierte objetos de Python (diccionarios o listas) en JSON de manera automática. Con el parámetro ensure_ascii=False, en caso de usar caracteres especiales, se garantiza una codificación adecuada en ciertos entornos.

Swagger y documentación

Para documentar la API y facilitar su uso, es posible adoptar Swagger (OpenAPI). En Flask, librerías como flasgger permiten anotar las rutas y generar la documentación automática. Esto aumenta la accesibilidad del CRUD y clarifica los campos esperados.

Buenas prácticas

• Mantener las rutas y la lógica de negocio separadas, asignando cada responsabilidad a un módulo distinto.
• Emplear un sistema de logs para capturar errores en entornos productivos y simplificar la depuración.
• Asegurar la aplicación con técnicas de autenticación y permisos cuando la API REST maneje datos sensibles.
• Implementar tests unitarios y de integración para garantizar que cada endpoint del CRUD funcione como se espera.

Con estos pasos, tu API REST en Flask queda establecida, permitiendo la creación, lectura, actualización y eliminación de recursos a través de peticiones HTTP. Este diseño CRUD forma la base de servicios escalables y flexibles, listos para conectarse con diferentes tipos de clientes, desde aplicaciones frontend hasta dispositivos móviles o sistemas de terceros.