Certificado de Flask API REST

Flask es un microframework web de Python que se ha consolidado como una de las opciones más populares para el desarrollo de APIs REST debido a su simplicidad, flexibilidad y capacidad de escalamiento. A diferencia de frameworks más pesados, Flask adopta una filosofía minimalista que permite a los desarrolladores construir aplicaciones web y APIs con el control total sobre los componentes que desean utilizar.

¿Qué es una API REST?

Una API REST (Representational State Transfer) es un estilo arquitectónico para diseñar servicios web que utiliza los métodos HTTP estándar para realizar operaciones sobre recursos. Las APIs REST se basan en principios fundamentales como la comunicación sin estado, el uso de URLs descriptivas para identificar recursos, y la manipulación de estos recursos mediante los métodos HTTP apropiados.

En el contexto moderno del desarrollo web, las APIs REST sirven como la columna vertebral de aplicaciones distribuidas, permitiendo que diferentes sistemas se comuniquen de manera eficiente y escalable. Flask proporciona las herramientas necesarias para implementar estos servicios de forma elegante y mantenible.

Fundamentos de Flask para APIs

Flask se distingue por su arquitectura modular que permite añadir funcionalidades según las necesidades específicas del proyecto. Para el desarrollo de APIs REST, Flask ofrece un conjunto de características esenciales que facilitan la creación de endpoints robustos y bien estructurados.

La gestión de rutas en Flask utiliza decoradores Python que mapean URLs específicas a funciones, permitiendo definir endpoints de manera intuitiva. Esta aproximación hace que el código sea legible y mantenible, características fundamentales en el desarrollo de APIs profesionales.

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/usuarios', methods=['GET'])
def obtener_usuarios():
    usuarios = [
        {'id': 1, 'nombre': 'Ana García'},
        {'id': 2, 'nombre': 'Carlos López'}
    ]
    return jsonify(usuarios)

Métodos HTTP y Operaciones CRUD

Las operaciones CRUD (Create, Read, Update, Delete) se mapean naturalmente con los métodos HTTP en una API REST. Flask facilita la implementación de estos métodos mediante el parámetro methods en el decorador de rutas.

El método GET se utiliza para recuperar información, siendo idempotente y seguro. Los métodos POST permiten crear nuevos recursos, mientras que PUT y PATCH se emplean para actualizaciones completas y parciales respectivamente. El método DELETE elimina recursos específicos del sistema.

@app.route('/api/productos', methods=['POST'])
def crear_producto():
    datos = request.get_json()
    # Lógica de creación
    return jsonify({'mensaje': 'Producto creado exitosamente'}), 201

@app.route('/api/productos/<int:producto_id>', methods=['DELETE'])
def eliminar_producto(producto_id):
    # Lógica de eliminación
    return '', 204

Manejo de Parámetros y Datos de Entrada

Flask proporciona múltiples mecanismos para capturar y procesar datos de entrada. Los parámetros de ruta se definen directamente en la URL utilizando sintaxis de marcadores de posición, mientras que los query strings se acceden mediante el objeto request.args.

Las cabeceras HTTP contienen metadatos importantes sobre la petición, incluyendo información de autenticación, tipo de contenido y preferencias del cliente. Flask permite acceder a estas cabeceras de forma sencilla para implementar lógica condicional basada en los metadatos de la petición.

@app.route('/api/productos/<int:categoria_id>')
def productos_por_categoria(categoria_id):
    limite = request.args.get('limite', 10, type=int)
    orden = request.args.get('orden', 'nombre')
    
    # Lógica de filtrado y ordenamiento
    return jsonify(productos_filtrados)

Gestión de Errores y Códigos de Estado

El manejo de errores robusto es fundamental en APIs profesionales. Flask permite implementar manejadores de errores personalizados que devuelven respuestas JSON estructuradas con códigos de estado HTTP apropiados.

Los códigos de estado HTTP comunican el resultado de cada operación de manera estándar. Los códigos 2xx indican éxito, los 4xx errores del cliente, y los 5xx errores del servidor. Una API bien diseñada utiliza estos códigos de forma consistente para facilitar la integración y depuración.

@app.errorhandler(404)
def recurso_no_encontrado(error):
    return jsonify({
        'error': 'Recurso no encontrado',
        'codigo': 404
    }), 404

@app.errorhandler(ValidationError)
def error_validacion(error):
    return jsonify({
        'error': 'Datos de entrada inválidos',
        'detalles': str(error)
    }), 400

Serialización y Validación de Datos

Pydantic se integra perfectamente con Flask para proporcionar validación de datos automática y serialización robusta. Esta biblioteca utiliza type hints de Python para definir esquemas de datos que validan automáticamente la entrada y salida de la API.

La serialización convierte objetos Python en formatos intercambiables como JSON, mientras que la deserialización realiza el proceso inverso. Pydantic automatiza estos procesos mientras proporciona mensajes de error detallados cuando los datos no cumplen con el esquema definido.

from pydantic import BaseModel, validator
from typing import Optional

class UsuarioSchema(BaseModel):
    nombre: str
    email: str
    edad: Optional[int] = None
    
    @validator('email')
    def validar_email(cls, v):
        if '@' not in v:
            raise ValueError('Email inválido')
        return v

Persistencia de Datos con SQLAlchemy

SQLAlchemy es el ORM (Object-Relational Mapping) más utilizado en el ecosistema Python para interactuar con bases de datos relacionales. Su integración con Flask mediante Flask-SQLAlchemy proporciona una interfaz elegante para definir modelos de datos y realizar operaciones de base de datos.

Los modelos SQLAlchemy definen la estructura de las tablas de base de datos utilizando clases Python. Cada atributo de clase representa una columna, y SQLAlchemy maneja automáticamente la traducción entre objetos Python y registros de base de datos.

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class Usuario(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    fecha_registro = db.Column(db.DateTime, default=datetime.utcnow)
    
    def to_dict(self):
        return {
            'id': self.id,
            'nombre': self.nombre,
            'email': self.email
        }

Relaciones y Consultas Avanzadas

SQLAlchemy permite definir relaciones entre modelos que reflejan las asociaciones de la base de datos. Las relaciones uno-a-muchos, muchos-a-muchos y uno-a-uno se implementan mediante el uso de claves foráneas y el método relationship().

Las consultas con joins permiten recuperar datos relacionados de múltiples tablas en una sola operación, optimizando el rendimiento de la API. SQLAlchemy proporciona una sintaxis expresiva para construir consultas complejas que se traducen automáticamente a SQL optimizado.

class Categoria(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(50), nullable=False)
    productos = db.relationship('Producto', backref='categoria', lazy=True)

class Producto(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(100), nullable=False)
    categoria_id = db.Column(db.Integer, db.ForeignKey('categoria.id'))

Migraciones de Base de Datos

Flask-Migrate utiliza Alembic para gestionar las migraciones de base de datos de forma automática. Las migraciones permiten evolucionar el esquema de la base de datos de manera controlada, manteniendo un historial de cambios que facilita el despliegue y la colaboración en equipo.

El sistema de migraciones detecta automáticamente los cambios en los modelos SQLAlchemy y genera scripts de migración que pueden aplicarse a diferentes entornos de manera consistente.

# Inicializar migraciones
flask db init

# Crear una nueva migración
flask db migrate -m "Agregar tabla usuarios"

# Aplicar migraciones
flask db upgrade

Seguridad y Autenticación

La seguridad en APIs REST requiere múltiples capas de protección. Flask-JWT-Extended proporciona implementación de JSON Web Tokens para autenticación stateless, mientras que bcrypt se utiliza para el hash seguro de contraseñas.

Los tokens JWT contienen información codificada sobre el usuario y sus permisos, eliminando la necesidad de mantener sesiones en el servidor. Esta aproximación es ideal para APIs que deben escalar horizontalmente.

from flask_jwt_extended import JWTManager, create_access_token, jwt_required
from werkzeug.security import generate_password_hash, check_password_hash

@app.route('/api/login', methods=['POST'])
def login():
    datos = request.get_json()
    usuario = Usuario.query.filter_by(email=datos['email']).first()
    
    if usuario and check_password_hash(usuario.password_hash, datos['password']):
        token = create_access_token(identity=usuario.id)
        return jsonify({'token': token})
    
    return jsonify({'error': 'Credenciales inválidas'}), 401

Configuración y Variables de Entorno

Las variables de entorno permiten configurar aplicaciones Flask de manera flexible sin hardcodear valores sensibles en el código fuente. Esta práctica es esencial para mantener la seguridad y facilitar el despliegue en diferentes entornos.

Flask proporciona múltiples mecanismos para gestionar la configuración, desde archivos de configuración hasta variables de entorno, permitiendo adaptar el comportamiento de la aplicación según el contexto de ejecución.

import os
from dotenv import load_dotenv

load_dotenv()

class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key'
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL')
    JWT_SECRET_KEY = os.environ.get('JWT_SECRET_KEY')

CORS y Integración Frontend

Flask-CORS resuelve las restricciones de Cross-Origin Resource Sharing que impiden que aplicaciones web accedan a APIs desde dominios diferentes. Esta configuración es fundamental cuando la API debe servir a aplicaciones frontend desplegadas en dominios distintos.

La configuración CORS adecuada balancea la accesibilidad con la seguridad, permitiendo el acceso desde orígenes autorizados mientras protege contra ataques de origen cruzado.

from flask_cors import CORS

app = Flask(__name__)
CORS(app, origins=['http://localhost:3000', 'https://miapp.com'])