Cree su primera API con Flask

Introducción

Crear una API RESTful robusta es esencial para las aplicaciones web modernas, ya que permite una comunicación fluida entre los servicios y los clientes. En esta guía completa, aprenderá a crear, proteger e implementar su primera API utilizando Flask, un marco web de Python ligero pero potente. Crearemos una API de ejemplo real que sirva datos de productos para un escenario de comercio electrónico y cubriremos características avanzadas como el manejo de errores, operaciones CRUD, integración de bases de datos, autenticación, modularización con Blueprints, documentación de API, pruebas y estrategias de implementación.

Importación de paquetes necesarios

Para mantener nuestro código organizado y evitar repeticiones, comenzamos importando los paquetes necesarios. Esto garantiza que todos los bloques de código posteriores tengan acceso a las bibliotecas necesarias.

# Importa las bibliotecas necesarias para el desarrollo de la API.
from flask import Flask, jsonify, request, abort

Creación de una API Flask básica con datos de ejemplos reales

Crearemos una API básica que sirva datos de productos para un ejemplo de comercio electrónico. Esto incluye un punto final de bienvenida y un punto final /api/products que devuelve una lista de productos.

API básica Ejemplo

# Inicialice la aplicación Flask.
app = Flask(__name__)

# Definir el punto final raíz.
@app.route("/")
def index():
    return jsonify({"message": "Welcome to the Products API"})

# Define un punto final para devolver una lista de productos.
@app.route("/api/products", methods=["GET"])
def get_products():
    # Ejemplo de datos de productos reales.
    products = [
        {"id": 1, "name": "Wireless Mouse", "price": 29.99, "category": "Electronics"},
        {"id": 2, "name": "Bluetooth Headphones", "price": 59.99, "category": "Electronics"},
        {"id": 3, "name": "Coffee Maker", "price": 79.99, "category": "Home Appliances"},
        {"id": 4, "name": "Electric Kettle", "price": 39.99, "category": "Home Appliances"},
        {"id": 5, "name": "Smartphone Stand", "price": 19.99, "category": "Accessories"}
    ]
    return jsonify({"products": products})

if __name__ == "__main__":
    # Ejecuta la aplicación en el puerto 5000 con la depuración habilitada.
    app.run(debug=True, port=5000)

Ejecución y prueba de la API

Para ejecutar tu API Flask, ejecuta tu script utilizando, por ejemplo, python api.py. Asegúrate de que tu API se ejecuta en un puerto específico (por ejemplo, 5000) para garantizar la coherencia. Por ejemplo:

if __name__ == "__main__":
    app.run(debug=True, port=5000)

Este comando inicia el servidor de desarrollo Flask en el puerto 5000 con la depuración habilitada.

Nota

Una vez que su API esté en funcionamiento, puede acceder a ella visitando http://localhost:5000/ en su navegador web.

Probar la API

Puedes probar tu API utilizando herramientas como cURL o Postman.

Uso de cURL:

curl http://127.0.0.1:5000/
curl http://127.0.0.1:5000/api/products

Usar Postman:
- Envía una solicitud GET a http://127.0.0.1:5000/api/products para ver la respuesta JSON con los datos del producto.

Gestión de errores y validación de entradas

Un manejo de errores robusto es crucial para una API de producción. Aquí añadimos controladores de errores y validación de entradas para garantizar que nuestra API responda adecuadamente a entradas y errores inesperados.

Ejemplo de gestión de errores

from flask import abort

@app.route("/api/divide", methods=["GET"])
def divide():
    try:
        a = float(request.args.get("a", ""))
        b = float(request.args.get("b", ""))
        if b == 0:
            abort(400, description="Division by zero is not allowed.")
        return jsonify({"result": a / b})
    except ValueError:
        abort(400, description="Invalid input. Please provide numeric values.")

@app.errorhandler(400)
def bad_request(error):
    response = jsonify({"error": error.description})
    response.status_code = 400
    return response

Operaciones CRUD

La gestión de recursos mediante operaciones CRUD (crear, leer, actualizar, eliminar) es esencial. A continuación se muestra un ejemplo sencillo que utiliza un almacén de datos en memoria para la gestión de productos.

Ejemplo CRUD

# Almacenamiento de datos en memoria para productos.
items = []

# Crear un nuevo producto.
@app.route("/api/items", methods=["POST"])
def create_item():
    data = request.get_json()
    items.append(data)
    return jsonify({"message": "Item created", "item": data}), 201

# Leer todos los productos.
@app.route("/api/items", methods=["GET"])
def get_items():
    return jsonify({"items": items})

# Actualizar un producto.
@app.route("/api/items/<int:item_id>", methods=["PUT"])
def update_item(item_id):
    data = request.get_json()
    if item_id < 0 or item_id >= len(items):
        abort(404, description="Item not found")
    items[item_id].update(data)
    return jsonify({"message": "Item updated", "item": items[item_id]})

# Eliminar un producto.
@app.route("/api/items/<int:item_id>", methods=["DELETE"])
def delete_item(item_id):
    if item_id < 0 or item_id >= len(items):
        abort(404, description="Item not found")
    deleted_item = items.pop(item_id)
    return jsonify({"message": "Item deleted", "item": deleted_item})

Integración de bases de datos

Para aplicaciones de producción, es esencial integrar una base de datos. Flask puede conectarse fácilmente a bases de datos utilizando un ORM como SQLAlchemy.

Ejemplo de integración con SQLAlchemy

# Configurar la base de datos SQLite.
from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///api.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

# Definir un modelo sencillo para los productos.
class Product(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)
    price = db.Column(db.Float, nullable=False)
    category = db.Column(db.String(80), nullable=False)

# Crea las tablas de la base de datos.
with app.app_context():
    db.create_all()

# Punto final para añadir un producto a la base de datos.
@app.route("/api/db/products", methods=["POST"])
def add_product():
    data = request.get_json()
    new_product = Product(name=data.get("name"), price=data.get("price"), category=data.get("category"))
    db.session.add(new_product)
    db.session.commit()
    return jsonify({"message": "Product added", "product": {"id": new_product.id, "name": new_product.name}}), 201

Autenticación y autorización

La seguridad de tu API es fundamental. A continuación se muestra un ejemplo básico que utiliza JWT para la autenticación.

Ejemplo de autenticación JWT

from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity

# Configurar JWT.
app.config["JWT_SECRET_KEY"] = "your-secret-key"
jwt = JWTManager(app)

@app.route("/api/login", methods=["POST"])
def login():
    username = request.json.get("username", None)
    password = request.json.get("password", None)
    # Para la demostración, utilice un nombre de usuario y una contraseña fijos.
    if username != "admin" or password != "password":
        abort(401, description="Invalid credentials")
    access_token = create_access_token(identity=username)
    return jsonify(access_token=access_token)

@app.route("/api/protected", methods=["GET"])
@jwt_required()
def protected():
    current_user = get_jwt_identity()
    return jsonify(logged_in_as=current_user)

Modularización con Blueprints

Para aplicaciones más grandes, organizar el código en Blueprints ayuda a mantener una estructura limpia. Los blueprints te permiten agrupar endpoints relacionados.

Ejemplo de plano

from flask import Blueprint

# Crea un plano para los puntos finales relacionados con el producto.
products_bp = Blueprint('products', __name__)

@products_bp.route("/api/blueprint/products", methods=["GET"])
def blueprint_get_products():
    return jsonify({"products": items})

# Registra el Blueprint con la aplicación Flask.
app.register_blueprint(products_bp)

Documentación de la API

La documentación interactiva de la API es esencial para las API de nivel de producción. Herramientas como Flasgger pueden generar automáticamente documentación Swagger.

Ejemplo de configuración de Flasgger

from flasgger import Swagger

# Inicialice Swagger para la documentación de la API.
swagger = Swagger(app)

@app.route("/api/docs")
def api_docs():
    return jsonify({"message": "Visit /apidocs for the interactive API documentation."})

Pruebas e implementación

Probar la API

Las pruebas automatizadas garantizan la fiabilidad de tu API. Por ejemplo, utilizando pytest:

def test_index():
    response = app.test_client().get("/")
    assert response.status_code == 200
    assert b"Welcome" in response.data

Ejecutar la API

Ejecuta tu aplicación Flask en el puerto 5000 incluyendo el siguiente comando:

if __name__ == "__main__":
    app.run(debug=True, port=5000)

Estrategias de implementación

Para la implementación en producción, tenga en cuenta las siguientes estrategias:

Usa un servidor WSGI de producción:
Implemente su aplicación Flask con Gunicorn:
```
gunicorn --bind 0.0.0.0:5000 your_script:app
```

Contenedorización:
Utiliza Docker para contenerizar tu aplicación. Por ejemplo, cree un Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "your_script:app"]

Reemplaza your_script por el nombre de tu archivo Python que contiene la aplicación Flask.

Orquestación:
Para el escalado y la gestión, considere el uso de Kubernetes o herramientas de orquestación similares.

Diagrama de flujo de implementación

flowchart LR
    A[Develop API] --> B[Write Tests]
    B --> C[Containerize with Docker]
    C --> D[Deploy with Gunicorn]
    D --> E[Orchestrate with Kubernetes]
    E --> F[Monitor & Scale]

Conclusión

Siguiendo esta guía completa, has aprendido a crear una API RESTful de nivel de producción con Flask utilizando datos de ejemplos reales. Hemos cubierto la creación de API, el manejo de errores, las operaciones CRUD, la integración de bases de datos, la autenticación, la modularización con Blueprints, la documentación de API, las pruebas y las estrategias de implementación. Con estas técnicas, puedes crear API robustas, seguras y escalables para aplicaciones del mundo real.

Lecturas adicionales

Feliz programación, y disfruta creando e implementando tu API de producción con Flask!

Explorar más artículos

Nota

Aquí hay más artículos de la misma categoría para ayudarte a profundizar en el tema.

Web scraping con BeautifulSoup

Guía práctica para extraer datos de sitios web