Tutorial completo: Cómo construir una API RESTful con Flask y Python

Aprender a crear una API RESTful con Python es un paso fundamental para cualquier desarrollador backend. En este tutorial, te guiamos paso a paso en la creación de una API utilizando Flask, un microframework ligero y poderoso que facilita el desarrollo backend. Este artículo es perfecto para desarrolladores principiantes e intermedios que desean iniciarse en el desarrollo backend Flask y crear APIs robustas, escalables y fáciles de mantener.

Índice

Introducción a Flask y las APIs RESTful
Paso 1: Instalación y configuración del entorno
Paso 2: Creando nuestra primera ruta y endpoint
Paso 3: Manejo de métodos HTTP (GET, POST, PUT, DELETE)
Paso 4: Validación de datos en la API
Paso 5: Integración con bases de datos (SQLite y PostgreSQL)
Paso 6: Pruebas básicas de la API
Conclusión y buenas prácticas

Introducción Flask y las APIs RESTful

Una API RESTful (Representational State Transfer) define un conjunto de reglas para crear servicios web escalables y fáciles de consumir. Flask es un microframework ligero de Python que permite construir APIs rápidas y modulares.

Convertirse en un experto en API RESTful con Python y específicamente en desarrollo backend Flask te abre puertas en el mundo del desarrollo web y móvil.

Paso 1: Instalación y configuración del entorno

Requisitos previos:

Python 3.7 o superior instalado
pip para instalar paquetes

1. Crear un entorno virtual

Esta es la mejor práctica para administrar dependencias:

python -m venv env
source env/bin/activate  # En Windows: env\Scripts\activate

python -m venv env

source env/bin/activate # En Windows: env\Scripts\activate

2. Instalar Flask y librerías necesarias

pip install Flask Flask-SQLAlchemy psycopg2-binary

1 2	pip install Flask Flask-SQLAlchemy psycopg2-binary

Nota: psycopg2-binary es para conectarse a PostgreSQL.

Paso 2: Creando nuestra primera ruta y endpoint

Vamos a crear un archivo app.py con el siguiente contenido que define una ruta básica:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify({'message': '¡Bienvenido a nuestra API RESTful con Python y Flask!'}), 200

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

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')

def home():

return jsonify({'message': '¡Bienvenido a nuestra API RESTful con Python y Flask!'}), 200

if __name__ == '__main__':

app.run(debug=True)

Explicación

Importamos Flask y jsonify para devolver JSON
Creamos aplicación Flask
Definimos ruta raíz / que responde con un mensaje JSON
Ejecutamos el servidor en modo debug para desarrollo

Para ejecutar:

python app.py

1 2	python app.py

Abre tu navegador en http://127.0.0.1:5000/ y verás el mensaje recibido.

Paso 3: Manejo de métodos HTTP (GET, POST, PUT, DELETE)

En REST, los métodos HTTP indican la acción que queremos sobre un recurso.

Ejemplo básico con un recurso “items”:

from flask import request

items = []  # Nuestra base de datos temporal

@app.route('/items', methods=['GET', 'POST'])
def manage_items():
    if request.method == 'GET':
        return jsonify(items), 200
    elif request.method == 'POST':
        data = request.get_json()
        item = {'id': len(items) + 1, 'name': data.get('name')}
        items.append(item)
        return jsonify(item), 201

@app.route('/items/<int:item_id>', methods=['GET', 'PUT', 'DELETE'])
def manage_item(item_id):
    item = next((i for i in items if i['id'] == item_id), None)
    if not item:
        return jsonify({'error': 'Item no encontrado'}), 404

    if request.method == 'GET':
        return jsonify(item), 200
    elif request.method == 'PUT':
        data = request.get_json()
        item['name'] = data.get('name', item['name'])
        return jsonify(item), 200
    elif request.method == 'DELETE':
        items.remove(item)
        return jsonify({'message': 'Item eliminado'}), 200

from flask import request

items = [] # Nuestra base de datos temporal

@app.route('/items', methods=['GET', 'POST'])

def manage_items():

if request.method == 'GET':

return jsonify(items), 200

elif request.method == 'POST':

data = request.get_json()

item = {'id': len(items) + 1, 'name': data.get('name')}

items.append(item)

return jsonify(item), 201

@app.route('/items/<int:item_id>', methods=['GET', 'PUT', 'DELETE'])

def manage_item(item_id):

item = next((i for i in items if i['id'] == item_id), None)

if not item:

return jsonify({'error': 'Item no encontrado'}), 404

if request.method == 'GET':

return jsonify(item), 200

elif request.method == 'PUT':

data = request.get_json()

item['name'] = data.get('name', item['name'])

return jsonify(item), 200

elif request.method == 'DELETE':

items.remove(item)

return jsonify({'message': 'Item eliminado'}), 200

Explicación paso a paso

En /items:
GET devuelve lista completa
POST añade un nuevo ítem
En /items/<item_id>:
GET obtiene un ítem por id
PUT actualiza nombre del ítem
DELETE elimina el ítem

Prueba con herramientas como Postman o curl para enviar solicitudes HTTP.

Paso 4: Validación de datos en la API

Es fundamental validar los datos recibidos para garantizar integridad.

Ejemplo simple usando Python:

from flask import abort

@app.route('/items', methods=['POST'])
def add_item():
    data = request.get_json()
    if not data or 'name' not in data or type(data['name']) is not str:
        abort(400, description='Nombre inválido')
    item = {'id': len(items) + 1, 'name': data['name']}
    items.append(item)
    return jsonify(item), 201

from flask import abort

@app.route('/items', methods=['POST'])

def add_item():

data = request.get_json()

if not data or 'name' not in data or type(data['name']) is not str:

abort(400, description='Nombre inválido')

item = {'id': len(items) + 1, 'name': data['name']}

items.append(item)

return jsonify(item), 201

Para validaciones más avanzadas, se recomienda usar librerías como marshmallow o pydantic.

Paso 5: Integración con bases de datos (SQLite y PostgreSQL)

1. Configuración de la base de datos con SQLAlchemy

Primero, agregamos conexión a base de datos.

from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///items.db'  # Usar SQLite
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

class Item(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)

    def to_dict(self):
        return {'id': self.id, 'name': self.name}

with app.app_context():
    db.create_all()

from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///items.db' # Usar SQLite

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

class Item(db.Model):

id = db.Column(db.Integer, primary_key=True)

name = db.Column(db.String(80), nullable=False)

def to_dict(self):

return {'id': self.id, 'name': self.name}

with app.app_context():

db.create_all()

2. Reescribir endpoints para usar base de datos

@app.route('/items', methods=['GET', 'POST'])
def manage_items_db():
    if request.method == 'GET':
        all_items = Item.query.all()
        return jsonify([item.to_dict() for item in all_items]), 200

    if request.method == 'POST':
        data = request.get_json()
        if not data or 'name' not in data:
            abort(400, description='Nombre es obligatorio')
        new_item = Item(name=data['name'])
        db.session.add(new_item)
        db.session.commit()
        return jsonify(new_item.to_dict()), 201

@app.route('/items/<int:item_id>', methods=['GET', 'PUT', 'DELETE'])
def manage_item_db(item_id):
    item = Item.query.get_or_404(item_id)

    if request.method == 'GET':
        return jsonify(item.to_dict()), 200
    elif request.method == 'PUT':
        data = request.get_json()
        item.name = data.get('name', item.name)
        db.session.commit()
        return jsonify(item.to_dict()), 200
    elif request.method == 'DELETE':
        db.session.delete(item)
        db.session.commit()
        return jsonify({'message': 'Item eliminado'}), 200

@app.route('/items', methods=['GET', 'POST'])

def manage_items_db():

if request.method == 'GET':

all_items = Item.query.all()

return jsonify([item.to_dict() for item in all_items]), 200

if request.method == 'POST':

data = request.get_json()

if not data or 'name' not in data:

abort(400, description='Nombre es obligatorio')

new_item = Item(name=data['name'])

db.session.add(new_item)

db.session.commit()

return jsonify(new_item.to_dict()), 201

@app.route('/items/<int:item_id>', methods=['GET', 'PUT', 'DELETE'])

def manage_item_db(item_id):

item = Item.query.get_or_404(item_id)

if request.method == 'GET':

return jsonify(item.to_dict()), 200

elif request.method == 'PUT':

data = request.get_json()

item.name = data.get('name', item.name)

db.session.commit()

return jsonify(item.to_dict()), 200

elif request.method == 'DELETE':

db.session.delete(item)

db.session.commit()

return jsonify({'message': 'Item eliminado'}), 200

3. Usar PostgreSQL

Solo necesitas cambiar la URI de SQLAlchemy:

# Para PostgreSQL
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://usuario:contraseña@localhost/dbname'

# Para PostgreSQL

app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://usuario:contraseña@localhost/dbname'

Recuerda instalar y tener configurado PostgreSQL localmente o usar un servicio externo.

Paso 6: Pruebas básicas de la API

Una buena práctica es probar tu API regularmente.

Usando curl desde una terminal:

Obtener todos los items:

curl -X GET http://127.0.0.1:5000/items

1 2	curl -X GET http://127.0.0.1:5000/items

Crear un item:

curl -X POST http://127.0.0.1:5000/items -H "Content-Type: application/json" -d '{"name": "Zapatos"}'

1 2	curl -X POST http://127.0.0.1:5000/items -H "Content-Type: application/json" -d '{"name": "Zapatos"}'

Actualizar item con id 1:

curl -X PUT http://127.0.0.1:5000/items/1 -H "Content-Type: application/json" -d '{"name": "Playeras"}'

1 2	curl -X PUT http://127.0.0.1:5000/items/1 -H "Content-Type: application/json" -d '{"name": "Playeras"}'

Eliminar item con id 1:

curl -X DELETE http://127.0.0.1:5000/items/1

1 2	curl -X DELETE http://127.0.0.1:5000/items/1

Usando Postman

Postman es una herramienta visual que facilita el envío de peticiones y el seguimiento de respuestas. Descárgalo e importa tu colección para empezar a probar.

Conclusión y buenas prácticas {#conclusión-y-buenas-prácticas}

Has aprendido cómo construir una API RESTful con Python y Flask, manejando diferentes métodos HTTP, validación básica de datos, e integración con bases de datos SQLite y PostgreSQL.

Buenas prácticas para seguir:

Usa entornos virtuales para manejar dependencias
Implementa validaciones robustas usando librerías externas
Aplica paginación y filtros para mejorar el rendimiento
Maneja errores y retorna respuestas claras
Usa migraciones de base de datos con Flask-Migrate
Documenta tu API con herramientas como Swagger o Flasgger
Prueba tu API con frameworks como pytest o herramientas externas

Invitamos a que experimentes extendiendo esta API, agregando autenticación, paginación y más.

¡Comienza hoy mismo y domina el desarrollo backend Flask con este tutorial Flask API!