Creación de una API sencilla con Flask: una guía paso a paso para desarrolladores

Flask es un microframework de Python ideal para crear aplicaciones web y API. Su simplicidad y flexibilidad lo convierten en una excelente opción tanto para principiantes como para desarrolladores experimentados. En este artículo, analizaremos cómo crear una API simple pero completa utilizando Flask.

Qué es una API y por qué la necesitas

Una API (interfaz de programación de aplicaciones) es un conjunto de reglas y herramientas que permiten que diferentes programas interactúen entre sí. La API RESTful utiliza solicitudes HTTP para realizar operaciones CRUD (Crear, Leer, Actualizar, Eliminar) sobre los datos. Las aplicaciones web modernas a menudo se dividen en frontend y backend, donde la API sirve como puente entre ellas.

Preparación del entorno

Antes de empezar, tenemos que instalar Flask. Se recomienda utilizar un entorno virtual para aislar las dependencias del proyecto:

python -m venv venv
source venv/bin/activate  # para Linux/Mac
venv\Scripts\activate  # para Windows
pip install flask

Creación de una API básica

Comencemos creando la aplicación Flask más simple. Crea el archivo app.py:

from flask import Flask, jsonify, request

app = Flask(__name__)

# Almacén temporal de datos
books = [
    {'id': 1, 'title': 'Clean code', 'author': 'Robert Martin'},
    {'id': 2, 'title': 'Python. To the heights of mastery', 'author': 'Luciano Ramallo'}
]

@app.route('/')
def home():
    return jsonify({'message': 'Welcome to the API library!'})

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

Ejecute la aplicación con el comando python app.py y el servidor estará disponible en http://127.0.0.1:5000/.

Implementación de operaciones CRUD

Ahora añadiremos endpoints para trabajar con libros.

Obtener todos los libros (GET)

@app.route('/api/books', methods=['GET'])
def get_books():
    return jsonify({'books': books, 'count': len(books)})

Obtener un libro por ID (GET)

@app.route('/api/books/<int:book_id>', methods=['GET'])
def get_book(book_id):
    book = next((book for book in books if book['id'] == book_id), None)
    if book:
        return jsonify(book)
    return jsonify({'error': 'Book not found'}), 404

Creación de un nuevo libro (POST)

@app.route('/api/books', methods=['POST'])
def create_book():
    if not request.json or 'title' not in request.json:
        return jsonify({'error': 'You must specify the name of the book'}), 400
    
    new_book = {
        'id': books[-1]['id'] + 1 if books else 1,
        'title': request.json['title'],
        'author': request.json.get('author', 'Unknown author')
    }
    books.append(new_book)
    return jsonify(new_book), 201

Actualización del libro (PUT)

@app.route('/api/books/<int:book_id>', methods=['PUT'])
def update_book(book_id):
    book = next((book for book in books if book['id'] == book_id), None)
    if not book:
        return jsonify({'error': 'Book not found'}), 404
    
    book['title'] = request.json.get('title', book['title'])
    book['author'] = request.json.get('author', book['author'])
    return jsonify(book)

Eliminar libro (DELETE)

@app.route('/api/books/<int:book_id>', methods=['DELETE'])
def delete_book(book_id):
    global books
    books = [book for book in books if book['id'] != book_id]
    return jsonify({'message': 'Book deleted successfully'})

Tratamiento de errores

Añadiremos controladores de errores para obtener respuestas más informativas:

@app.errorhandler(404)
def not_found(error):
    return jsonify({'error': 'Resource not found'}), 404

@app.errorhandler(500)
def internal_error(error):
    return jsonify({'error': 'Internal server error'}), 500

Prueba de API

Para las pruebas, puedes usar curl, Postman o la biblioteca de Python requests:

# Obtener todos los libros
curl http://127.0.0.1:5000/api/books

# Crear un nuevo libro
curl -X POST http://127.0.0.1:5000/api/books \
  -H "Content-Type: application/json" \
  -d '{"title":"Perfect Code","author":"Steve McConnell"}' Actualizar libro
curl -X PUT http://127.0.0.1:5000/api/books/1 \
  -H "Content-Type: application/json" \
  -d '{"title":"Clean Code (new edition)"}'# Eliminar libro
curl -X DELETE http://127.0.0.1:5000/api/books/2

Añadir validación

Para una validación de datos más confiable, puedes usar la biblioteca flask-marshmallow:

from flask_marshmallow import Marshmallow

ma = Marshmallow(app)

class BookSchema(ma.Schema):
    class Meta:
        fields = ('id', 'title', 'author')

book_schema = BookSchema()
books_schema = BookSchema(many=True)

Conexión de la base de datos

Para aplicaciones reales, vale la pena usar una base de datos. Instalemos Flask-SQLAlchemy:

pip install flask-sqlalchemy

Ejemplo de un modelo de libro con SQLAlchemy:

from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///books.db'
db = SQLAlchemy(app)

class Book(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    author = db.Column(db.String(100))
    
    def to_dict(self):
        return {
            'id': self.id,
            'title': self.title,
            'author': self.author
        }

Añadir CORS

Si tu API será utilizada por una aplicación frontend, necesitas configurar CORS:

pip install flask-cors

from flask_cors import CORS

CORS(app)

Seguridad y mejores prácticas

Al desarrollar una API, es importante tener en cuenta la seguridad. Utiliza variables de entorno para almacenar datos confidenciales, implementa la autenticación a través de tokens JWT, limita el número de solicitudes (limitación de velocidad), valida todos los datos entrantes y utiliza HTTPS en producción.

También se recomienda organizar la estructura del proyecto dividiendo el código en módulos: crear archivos separados para modelos, rutas y configuraciones. Utiliza Blueprint para agrupar los endpoints relacionados, lo que hace que el código sea más mantenible y escalable.

Implementación de la API

Para implementar una aplicación Flask en producción, utiliza un servidor WSGI como Gunicorn:

pip install gunicorn
gunicorn -w 4 app:app

Plataformas populares para la implementación: Heroku, DigitalOcean, AWS o VPS tradicional con nginx como proxy inverso.

Conclusión

Creamos una API RESTful completa con Flask, que incluye todas las operaciones CRUD básicas, manejo de errores y validación de datos. Flask proporciona una base mínima pero poderosa para crear una API de cualquier complejidad. Los siguientes pasos pueden ser añadir autenticación, documentar la API con Swagger, escribir pruebas unitarias y optimizar el rendimiento.

¿Quieres profundizar en Python y el desarrollo web?

Anexo Kodik ofrece cursos estructurados en Python, JavaScript, trabajo con API y muchas otras tecnologías. La formación se basa en ejemplos prácticos con explicaciones paso a paso.

Únete a nuestro Canal de Telegram, donde encontrarás materiales útiles, consejos de programación y el apoyo de una comunidad activa de desarrolladores dispuestos a ayudarte en cualquier etapa de tu aprendizaje.