Tutorial API REST Flask: Cómo Crear una API RESTful con Python y SQLAlchemy
Introducción
En este tutorial API REST Flask, te guiaremos paso a paso para construir una API RESTful usando Flask y SQLAlchemy en Python. Esta guía está diseñada para desarrolladores principiantes e intermedios interesados en el desarrollo backend Flask. Aprenderás desde la instalación del entorno hasta la creación de rutas para operaciones CRUD, el manejo de errores y la validación, hasta las pruebas básicas con Postman y curl.
Contenido
- Instalación y configuración del entorno
- Creación y configuración de la aplicación Flask
- Definición de modelos con SQLAlchemy
- Implementar rutas para operaciones CRUD
- Manejo de errores y validaciones
- Pruebas básicas de la API
- Conclusión y buenas prácticas
Instalación y configuración del entorno
1. Crear entorno virtual
Antes de comenzar, es una buena práctica usar un entorno virtual para aislar las dependencias del proyecto.
|
1 2 3 |
python3 -m venv venv source venv/bin/activate # En Windows: venv\Scripts\activate |
2. Instalar dependencias
Instalaremos Flask para el framework web y SQLAlchemy para la gestión de la base de datos, junto con Flask-SQLAlchemy que integra ambos.
|
1 2 |
pip install flask flask_sqlalchemy |
Para pruebas más adelante, recomendamos instalar además:
|
1 2 |
pip install flask_testing |
Opcional: Instala psycopg2 si usas PostgreSQL, o solo para pruebas SQLite no necesitas nada extra.
Creación y configuración de la aplicación Flask
1. Estructura básica del proyecto
Organiza los archivos de manera sencilla:
|
1 2 3 4 5 |
/my_flask_api |-- app.py |-- models.py |-- requirements.txt |
2. Archivo principal app.py
Crea el archivo app.py y configura la aplicación Flask y la base de datos:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from flask import Flask, jsonify, request from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) # Configuración base de datos SQLite para simplicidad app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # Inicializar SQLAlchemy db = SQLAlchemy(app) if __name__ == '__main__': app.run(debug=True) |
3. Inicializar base de datos
Antes de continuar, crea la base de datos ejecutando el shell de Python dentro del entorno y crea las tablas:
|
1 2 3 4 5 |
from app import db # Crear y aplicar tablas según modelos definidos db.create_all() |
Definición de modelos con SQLAlchemy
Los modelos definen la estructura de los datos en la base de datos.
1. Crear archivo models.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
from app import db class Item(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), nullable=False) description = db.Column(db.String(200)) def __repr__(self): return f'<Item {self.name}>' def to_dict(self): """Convierte el objeto a diccionario para JSON.""" return { 'id': self.id, 'name': self.name, 'description': self.description } |
2. Importar el modelo a app.py
Para que nuestro modelo pueda registrarse y ser utilizado:
|
1 2 |
from models import Item |
Recuerda ejecutar db.create_all() para crear las tablas según tu modelo.
Implementar rutas para operaciones CRUD
Definiremos las rutas necesarias para Crear, Leer, Actualizar y Eliminar (CRUD) Items.
1. Crear un nuevo Item (POST)
|
1 2 3 4 5 6 7 8 9 10 |
@app.route('/items', methods=['POST']) def create_item(): data = request.get_json() if not data or not 'name' in data: return jsonify({'error': 'El campo nombre es obligatorio'}), 400 new_item = Item(name=data['name'], description=data.get('description', '')) db.session.add(new_item) db.session.commit() return jsonify(new_item.to_dict()), 201 |
2. Obtener todos los Items (GET)
|
1 2 3 4 5 |
@app.route('/items', methods=['GET']) def get_items(): items = Item.query.all() return jsonify([item.to_dict() for item in items]), 200 |
3. Obtener un Item por ID (GET)
|
1 2 3 4 5 |
@app.route('/items/<int:item_id>', methods=['GET']) def get_item(item_id): item = Item.query.get_or_404(item_id) return jsonify(item.to_dict()), 200 |
4. Actualizar un Item (PUT)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
@app.route('/items/<int:item_id>', methods=['PUT']) def update_item(item_id): item = Item.query.get_or_404(item_id) data = request.get_json() if not data or not 'name' in data: return jsonify({'error': 'El campo nombre es obligatorio para actualizar'}), 400 item.name = data['name'] item.description = data.get('description', item.description) db.session.commit() return jsonify(item.to_dict()), 200 |
5. Eliminar un Item (DELETE)
|
1 2 3 4 5 6 7 |
@app.route('/items/<int:item_id>', methods=['DELETE']) def delete_item(item_id): item = Item.query.get_or_404(item_id) db.session.delete(item) db.session.commit() return jsonify({'message': 'Item eliminado correctamente'}), 200 |
Manejo de errores y validaciones
1. Uso de get_or_404
Flask-SQLAlchemy incluye get_or_404 que retorna un error 404 si no se encuentra el recurso, evitando código adicional.
2. Validación básica
Validamos la presencia del campo name tanto en creación como actualización para evitar errores.
3. Personalizar mensajes de error
Puedes manejar errores personalizados con decoradores:
|
1 2 3 4 5 6 7 8 |
@app.errorhandler(404) def not_found(error): return jsonify({'error': 'Recurso no encontrado'}), 404 @app.errorhandler(400) def bad_request(error): return jsonify({'error': 'Solicitud inválida'}), 400 |
Pruebas básicas de la API
Para probar tu API REST Flask, puedes usar Postman o la terminal usando curl.
1. Probar con curl
- Crear un Item:
|
1 2 |
curl -X POST http://127.0.0.1:5000/items -H "Content-Type: application/json" -d '{"name": "Test Item", "description": "Descripción de prueba"}' |
- Obtener todos los Items:
|
1 2 |
curl http://127.0.0.1:5000/items |
- Obtener un Item por ID:
|
1 2 |
curl http://127.0.0.1:5000/items/1 |
- Actualizar un Item:
|
1 2 |
curl -X PUT http://127.0.0.1:5000/items/1 -H "Content-Type: application/json" -d '{"name": "Item Actualizado", "description": "Nueva descripción"}' |
- Eliminar un Item:
|
1 2 |
curl -X DELETE http://127.0.0.1:5000/items/1 |
2. Probar con Postman
- Importa la URL base
http://127.0.0.1:5000/ - Crea peticiones HTTP con los métodos POST, GET, PUT, DELETE
- Define JSON en el body para POST y PUT
Conclusión y buenas prácticas
Has aprendido a crear una API RESTful básica usando Flask y SQLAlchemy, desde la configuración hasta las operaciones CRUD, manejo de errores y pruebas.
Buenas prácticas para desarrollar tu API REST Flask:
- Usa entornos virtuales para manejar dependencias.
- Separa la lógica en archivos: modelos, rutas, configuración.
- Valida siempre los datos recibidos para evitar errores en la base de datos.
- Maneja errores de forma amigable para que quien consuma la API tenga claridad.
- Añade documentación o comentarios para facilitar el mantenimiento.
- Usa herramientas como Postman para testear y automatizar pruebas.
Próximos pasos sugeridos:
- Añadir autenticación con tokens JWT.
- Implementar paginación para grandes volúmenes.
- Usar migraciones con Flask-Migrate para gestionar base de datos.
- Desplegar tu API en servicios como Heroku o AWS.
¡Empieza a construir tus propias APIs backend con Python usando Flask y SQLAlchemy! Explora más y profundiza en desarrollo backend Flask para ampliar tus habilidades profesionales y crear proyectos robustos.
¡Manos a la obra y éxito en tu aprendizaje!
