Cómo Crear una API RESTful con Python y Flask: Tutorial Paso a Paso
Introducción
Si estás interesado en el desarrollo backend con Flask y quieres aprender a crear una API RESTful Python desde cero, este tutorial es para ti. Aquí, te guiaré paso a paso para que puedas construir una API sencilla pero completa, abarcando desde la instalación y configuración del entorno, hasta la creación de rutas, manejo de peticiones HTTP (GET, POST, PUT, DELETE), gestión de errores y conexión a una base de datos básica.
Este Flask tutorial está pensado tanto para desarrolladores principiantes como para quienes tienen conocimientos intermedios y desean adentrarse en el mundo del backend con Python.
Índice
- Qué es una API RESTful y por qué usar Flask
- Instalación y configuración del entorno
- Creación básica de la API en Flask
- Manejo de peticiones HTTP
- GET
- POST
- PUT
- DELETE
- Manejo de errores en la API
- Conexión a una base de datos sencilla con SQLite
- Conclusión y buenas prácticas
1. Qué es una API RESTful y por qué usar Flask
Una API RESTful es una interfaz de programación que sigue los principios REST (Representational State Transfer) para facilitar la comunicación entre un cliente y un servidor. Se basa en el protocolo HTTP y sus métodos (GET, POST, etc.) para realizar distintas operaciones.
Flask es un micro framework para Python que facilita la creación de aplicaciones web y APIs debido a su simplicidad y flexibilidad, ideal para proyectos pequeños y medianos.
2. Instalación y configuración del entorno
Antes de comenzar a programar, necesitamos configurar nuestro entorno de trabajo.
Paso 1: Instalar Python
Asegúrate de tener instalada la versión 3.6 o superior de Python. Puedes verificarlo con:
|
1 2 |
python --version |
Paso 2: Crear un entorno virtual
Para evitar conflictos con otras librerías, crea un entorno virtual:
|
1 2 |
python -m venv venv |
Activa el entorno virtual:
- En Windows:
|
1 2 |
venv\Scripts\activate |
- En macOS/Linux:
|
1 2 |
source venv/bin/activate |
Paso 3: Instalar Flask
Instala Flask usando pip:
|
1 2 |
pip install Flask |
Paso 4 (opcional): Instalar SQLite si deseas usar base de datos
SQLite viene preinstalado con Python en la mayoría de las distribuciones, por lo que no deberías necesitar instalar nada extra.
3. Creación básica de la API en Flask
Ahora sí, empecemos a construir nuestra API.
Paso 1: Crear archivo principal
Crea un archivo llamado app.py.
Paso 2: Código básico para levantar el servidor
|
1 2 3 4 5 6 7 8 9 10 11 |
from flask import Flask app = Flask(__name__) @app.route('/') def home(): return "¡Hola, esta es nuestra API RESTful con Flask!" if __name__ == '__main__': app.run(debug=True) |
Paso 3: Ejecutar la aplicación
En la terminal, corre:
|
1 2 |
python app.py |
Abre tu navegador en http://127.0.0.1:5000/ y deberías ver el mensaje.
4. Manejo de peticiones HTTP
Las APIs RESTful se basan en el uso de métodos HTTP para realizar operaciones. Veamos cómo implementarlos.
Crearemos una API para manejar una lista de tareas (to-do list).
Agrega este código en app.py:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
from flask import Flask, jsonify, request, abort app = Flask(__name__) tareas = [ {"id": 1, "tarea": "Aprender Flask", "completado": False}, {"id": 2, "tarea": "Crear una API", "completado": False} ] # Obtener todas las tareas @app.route('/api/tareas', methods=['GET']) def obtener_tareas(): return jsonify({'tareas': tareas}) # Obtener una tarea por ID @app.route('/api/tareas/<int:tarea_id>', methods=['GET']) def obtener_tarea(tarea_id): tarea = next((t for t in tareas if t['id'] == tarea_id), None) if tarea is None: abort(404, description="Tarea no encontrada") return jsonify(tarea) # Crear una nueva tarea @app.route('/api/tareas', methods=['POST']) def crear_tarea(): if not request.json or 'tarea' not in request.json: abort(400, description="La tarea es requerida") nueva_tarea = { 'id': tareas[-1]['id'] + 1 if tareas else 1, 'tarea': request.json['tarea'], 'completado': False } tareas.append(nueva_tarea) return jsonify(nueva_tarea), 201 # Actualizar una tarea existente @app.route('/api/tareas/<int:tarea_id>', methods=['PUT']) def actualizar_tarea(tarea_id): tarea = next((t for t in tareas if t['id'] == tarea_id), None) if tarea is None: abort(404, description="Tarea no encontrada") if not request.json: abort(400, description="Datos no proporcionados") tarea['tarea'] = request.json.get('tarea', tarea['tarea']) tarea['completado'] = request.json.get('completado', tarea['completado']) return jsonify(tarea) # Eliminar una tarea @app.route('/api/tareas/<int:tarea_id>', methods=['DELETE']) def eliminar_tarea(tarea_id): global tareas tarea = next((t for t in tareas if t['id'] == tarea_id), None) if tarea is None: abort(404, description="Tarea no encontrada") tareas = [t for t in tareas if t['id'] != tarea_id] return jsonify({'result': True}) if __name__ == '__main__': app.run(debug=True) |
Explicación paso a paso:
- Definimos una lista
tareascomo nuestro “almacén” temporal. GET /api/tareas: devuelve todas las tareas.GET /api/tareas/<id>: devuelve una tarea específica o un error 404.POST /api/tareas: crea una nueva tarea basándose en los datos JSON recibidos.PUT /api/tareas/<id>: actualiza una tarea existente.DELETE /api/tareas/<id>: elimina una tarea específica.
Puedes probar estas rutas usando herramientas como Postman o curl.
Ejemplo de petición POST con curl:
|
1 2 |
curl -i -H "Content-Type: application/json" -X POST -d '{"tarea":"Estudiar Flask"}' http://127.0.0.1:5000/api/tareas |
5. Manejo de errores en la API
El manejo adecuado de errores mejora la experiencia del usuario y facilita la depuración.
Modificamos el código para personalizar los errores:
|
1 2 3 4 5 6 7 8 9 10 |
from flask import make_response @app.errorhandler(404) def not_found(error): return make_response(jsonify({'error': 'No encontrado', 'mensaje': error.description}), 404) @app.errorhandler(400) def bad_request(error): return make_response(jsonify({'error': 'Solicitud incorrecta', 'mensaje': error.description}), 400) |
Agrega estas funciones en tu archivo, y Flask retornará mensajes JSON amigables para estos casos.
6. Conexión a una base de datos sencilla con SQLite
Para que los datos persistan y no dependan de listas en memoria, conectemos la API a una base de datos SQLite.
Paso 1: Instalar SQLAlchemy
SQLAlchemy es un ORM que facilita la interacción con bases de datos.
|
1 2 |
pip install Flask-SQLAlchemy |
Paso 2: Configurar la base de datos en app.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
from flask_sqlalchemy import SQLAlchemy app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///tareas.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) # Definir modelo de tarea class Tarea(db.Model): id = db.Column(db.Integer, primary_key=True) tarea = db.Column(db.String(200), nullable=False) completado = db.Column(db.Boolean, default=False) def to_dict(self): return { 'id': self.id, 'tarea': self.tarea, 'completado': self.completado } # Crear la base de datos with app.app_context(): db.create_all() |
Paso 3: Modificar rutas para usar la base de datos
Ejemplo para obtener todas las tareas:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
@app.route('/api/tareas', methods=['GET']) def obtener_tareas(): tareas = Tarea.query.all() return jsonify({'tareas': [t.to_dict() for t in tareas]}) @app.route('/api/tareas', methods=['POST']) def crear_tarea(): if not request.json or 'tarea' not in request.json: abort(400, description="La tarea es requerida") nueva_tarea = Tarea(tarea=request.json['tarea']) db.session.add(nueva_tarea) db.session.commit() return jsonify(nueva_tarea.to_dict()), 201 # Continúa adaptando las demás rutas (GET por ID, PUT, DELETE) de manera similar |
Si deseas, puedo ayudarte a adaptar todas las rutas para integrar SQLAlchemy. Aquí el objetivo principal es mostrar cómo conectar la base SQLite para persistencia.
7. Conclusión y buenas prácticas
En este tutorial, aprendiste a crear una API RESTful Python utilizando Flask, desde la instalación y configuración del entorno hasta la conexión con una base de datos SQLite usando SQLAlchemy.
Buenas prácticas:
- Usa entornos virtuales para aislar dependencias.
- Utiliza validación y manejo de errores para responder con mensajes claros.
- Divide tu código en módulos o blueprints para mantenerlo organizado.
- Implementa autenticación si la API será pública o crítica.
- Prueba tus endpoints con herramientas como Postman o curl.
- Documenta tu API, puedes usar Swagger o Postman para facilitar el uso.
¿Qué sigue?
Ahora que sabes cómo crear una API básica, te invito a que amplíes la funcionalidad agregando autenticación (JWT), paginación, filtros y tests automáticos.
¿Listo para llevar tu desarrollo backend Flask al siguiente nivel? Comienza ahora mismo a crear tu propia API con Python siguiendo estos pasos y mejora tus proyectos con servicios robustos y escalables.
Recursos adicionales
¡Feliz desarrollo!
