Tutorial API REST Flask: Cómo crear una API RESTful con Python y Flask paso a paso

Bienvenido a este tutorial API REST Flask, diseñado especialmente para desarrolladores principiantes e intermedios que desean aprender cómo crear una API RESTful con Python y Flask. Aquí aprenderás cómo configurar tu entorno de desarrollo, construir rutas y endpoints, manipular peticiones HTTP (GET, POST, PUT, DELETE), integrar bases de datos con SQLAlchemy, validar datos y manejar errores de forma eficiente.

Este tutorial es ideal si quieres comenzar en el desarrollo backend Flask y necesitas una guía práctica y clara para construir tu primera API RESTful Python desde cero.

¿Qué es una API RESTful?

Una API RESTful es una interfaz que permite la comunicación entre diferentes sistemas usando el protocolo HTTP. REST (Representational State Transfer) es un estilo de arquitectura que hace que la API sea sencilla, escalable y fácil de mantener.

Requisitos previos

Conocimientos básicos de Python
Python 3.x instalado
Familiaridad básica con HTTP y REST

Si aún no tienes instalado Python, puedes descargarlo desde python.org.

Paso 1: Configuración del entorno de desarrollo

Vamos a utilizar Flask, un microframework para Python, junto con Flask-SQLAlchemy para la base de datos.

1.1 Crear y activar entorno virtual

Es buena práctica crear un entorno virtual para manejar dependencias.

# Crear entorno virtual
python -m venv venv

# Activar entorno virtual
# Windows
env\Scripts\activate

# macOS/Linux
source venv/bin/activate

# Crear entorno virtual

python -m venv venv

# Activar entorno virtual

# Windows

env\Scripts\activate

# macOS/Linux

source venv/bin/activate

1.2 Instalar dependencias

Instalamos Flask, Flask-SQLAlchemy y Flask-Marshmallow (para la validación y serialización de datos)

pip install Flask Flask-SQLAlchemy Flask-Marshmallow marshmallow-sqlalchemy

1 2	pip install Flask Flask-SQLAlchemy Flask-Marshmallow marshmallow-sqlalchemy

Paso 2: Creando el proyecto básico con Flask

En un directorio de tu elección, crea un archivo llamado app.py y agrega lo siguiente:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "¡Hola! Esta es tu API REST con Flask."

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

from flask import Flask

app = Flask(__name__)

@app.route('/')

def home():

return "¡Hola! Esta es tu API REST con Flask."

if __name__ == '__main__':

app.run(debug=True)

Ejecuta tu aplicación

python app.py

1 2	python app.py

Ve a http://127.0.0.1:5000/ en tu navegador. Deberías ver el mensaje.

Paso 3: Configurar la base de datos con SQLAlchemy

Para este tutorial, crearemos una API simple que maneje un recurso llamado “Tareas”.

3.1 Configuración de la base de datos

Agrega la configuración a app.py. Usaremos SQLite para simplicidad.

from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///tareas.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///tareas.db'

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

3.2 Crear el modelo Tarea

class Tarea(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    titulo = db.Column(db.String(100), nullable=False)
    descripcion = db.Column(db.String(200))
    completado = db.Column(db.Boolean, default=False)

    def __repr__(self):
        return f"<Tarea {self.titulo}>"

class Tarea(db.Model):

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

titulo = db.Column(db.String(100), nullable=False)

descripcion = db.Column(db.String(200))

completado = db.Column(db.Boolean, default=False)

def __repr__(self):

return f"<Tarea {self.titulo}>"

3.3 Crear la base de datos

Abre una terminal de Python dentro del entorno virtual y ejecuta:

from app import db

# Crea las tablas
 db.create_all()

from app import db

# Crea las tablas

db.create_all()

Esto generará el archivo tareas.db con la tabla correspondiente.

Paso 4: Serialización y Validación con Marshmallow

Para convertir objetos a JSON y validar datos.

4.1 Crear Schema para Tarea

from flask_marshmallow import Marshmallow

ma = Marshmallow(app)

class TareaSchema(ma.SQLAlchemyAutoSchema):
    class Meta:
        model = Tarea
        load_instance = True

tarea_schema = TareaSchema()          # Para una tarea
tareas_schema = TareaSchema(many=True)  # Para múltiples tareas

from flask_marshmallow import Marshmallow

ma = Marshmallow(app)

class TareaSchema(ma.SQLAlchemyAutoSchema):

class Meta:

model = Tarea

load_instance = True

tarea_schema = TareaSchema() # Para una tarea

tareas_schema = TareaSchema(many=True) # Para múltiples tareas

Paso 5: Creación de endpoints RESTful

5.1 GET – Obtener todas las tareas

from flask import jsonify

@app.route('/tareas', methods=['GET'])
def get_tareas():
    tareas = Tarea.query.all()
    return tareas_schema.jsonify(tareas)

from flask import jsonify

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

def get_tareas():

tareas = Tarea.query.all()

return tareas_schema.jsonify(tareas)

5.2 GET – Obtener una tarea por ID

@app.route('/tareas/<int:id>', methods=['GET'])
def get_tarea(id):
    tarea = Tarea.query.get_or_404(id)
    return tarea_schema.jsonify(tarea)

@app.route('/tareas/<int:id>', methods=['GET'])

def get_tarea(id):

tarea = Tarea.query.get_or_404(id)

return tarea_schema.jsonify(tarea)

5.3 POST – Crear una nueva tarea

from flask import request

@app.route('/tareas', methods=['POST'])
def crear_tarea():
    data = request.get_json()
    # Validar y cargar datos
    try:
        nueva_tarea = tarea_schema.load(data)
    except Exception as e:
        return jsonify({'error': str(e)}), 400

    db.session.add(nueva_tarea)
    db.session.commit()

    return tarea_schema.jsonify(nueva_tarea), 201

from flask import request

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

def crear_tarea():

data = request.get_json()

# Validar y cargar datos

try:

nueva_tarea = tarea_schema.load(data)

except Exception as e:

return jsonify({'error': str(e)}), 400

db.session.add(nueva_tarea)

db.session.commit()

return tarea_schema.jsonify(nueva_tarea), 201

5.4 PUT – Actualizar una tarea existente

@app.route('/tareas/<int:id>', methods=['PUT'])
def actualizar_tarea(id):
    tarea = Tarea.query.get_or_404(id)
    data = request.get_json()

    try:
        # Actualizar campos
        tarea.titulo = data.get('titulo', tarea.titulo)
        tarea.descripcion = data.get('descripcion', tarea.descripcion)
        tarea.completado = data.get('completado', tarea.completado)

        db.session.commit()
    except Exception as e:
        return jsonify({'error': str(e)}), 400

    return tarea_schema.jsonify(tarea)

@app.route('/tareas/<int:id>', methods=['PUT'])

def actualizar_tarea(id):

tarea = Tarea.query.get_or_404(id)

data = request.get_json()

try:

# Actualizar campos

tarea.titulo = data.get('titulo', tarea.titulo)

tarea.descripcion = data.get('descripcion', tarea.descripcion)

tarea.completado = data.get('completado', tarea.completado)

db.session.commit()

except Exception as e:

return jsonify({'error': str(e)}), 400

return tarea_schema.jsonify(tarea)

5.5 DELETE – Borrar una tarea

@app.route('/tareas/<int:id>', methods=['DELETE'])
def borrar_tarea(id):
    tarea = Tarea.query.get_or_404(id)

    db.session.delete(tarea)
    db.session.commit()

    return jsonify({'mensaje': 'Tarea eliminada correctamente.'}), 200

@app.route('/tareas/<int:id>', methods=['DELETE'])

def borrar_tarea(id):

tarea = Tarea.query.get_or_404(id)

db.session.delete(tarea)

db.session.commit()

return jsonify({'mensaje': 'Tarea eliminada correctamente.'}), 200

Paso 6: Manejo de errores personalizados

Para que nuestra API sea robusta, añadiremos manejo de errores para peticiones inválidas.

from flask import make_response

@app.errorhandler(404)
def recurso_no_encontrado(error):
    return make_response(jsonify({'error': 'Recurso no encontrado'}), 404)

@app.errorhandler(400)
def error_peticion_invalida(error):
    return make_response(jsonify({'error': 'Petición inválida'}), 400)

from flask import make_response

@app.errorhandler(404)

def recurso_no_encontrado(error):

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

@app.errorhandler(400)

def error_peticion_invalida(error):

return make_response(jsonify({'error': 'Petición inválida'}), 400)

Paso 7: Pruebas de la API

Puedes usar herramientas como Postman o curl para probar los endpoints.

Ejemplo de una petición POST para crear una tarea usando curl:

curl -X POST http://127.0.0.1:5000/tareas -H "Content-Type: application/json" -d '{"titulo": "Aprender Flask", "descripcion": "Crear una API RESTful básica"}'

1 2	curl -X POST http://127.0.0.1:5000/tareas -H "Content-Type: application/json" -d '{"titulo": "Aprender Flask", "descripcion": "Crear una API RESTful básica"}'

Buenas prácticas finales

Utiliza variables de entorno para configuración sensible (por ejemplo, URI de base de datos).
Implementa autenticación y autorización para proteger los endpoints.
Añade paginación para respuestas con muchos datos.
Realiza pruebas unitarias y de integración.
Documenta tu API con herramientas como Swagger o Postman.

Conclusión

En este tutorial API REST Flask has aprendido cómo configurar un entorno de desarrollo para crear una API RESTful Python utilizando Flask, manejar distintos tipos de peticiones HTTP, integrar una base de datos con SQLAlchemy, validar datos y administrar errores de forma sencilla y clara.

Con la base que tienes, puedes avanzar hacia proyectos más complejos e incluso integrar Flask con otros servicios.

¡No dudes en experimentar por tu cuenta y seguir profundizando en el desarrollo backend Flask!

¿Quieres más tutoriales útiles y detallados? Suscríbete a nuestro blog y empieza a dominar el desarrollo backend hoy mismo.