Tutorial Completo para Crear una API RESTful con Flask en Python

Si estás comenzando en el desarrollo backend en Python y quieres aprender a construir una API RESTful desde cero, este tutorial es para ti. Aquí te guiaré paso a paso para que, aunque seas principiante, entiendas cómo crear una API usando Flask, uno de los frameworks más populares y sencillos de Python.

¿Qué aprenderás en este tutorial?

Instalación y configuración del entorno para Flask
Concepto de rutas y métodos HTTP (GET, POST, PUT, DELETE)
Manejo de datos en formato JSON
Uso de la extensión Flask-RESTful para simplificar el desarrollo
Buenas prácticas y recomendaciones para programación Flask para principiantes

¡Vamos allá!

1. Instalación y Configuración del Entorno

Antes de escribir código, debes preparar tu entorno de desarrollo.

Paso 1: Instalar Python

Asegúrate de tener Python instalado (versión 3.6 o superior). Puedes verificarlo con:

python --version
# o en algunos sistemas
python3 --version

python --version

# o en algunos sistemas

python3 --version

Si no está instalado, descárgalo en python.org.

Paso 2: Crear un entorno virtual (opcional pero recomendado)

Los entornos virtuales permiten aislar las dependencias de tu proyecto.

# Crear un entorno virtual llamado venv
python -m venv venv

# Activar el entorno (en Windows)
venv\Scripts\activate

# Activar el entorno (en Mac/Linux)
source venv/bin/activate

# Crear un entorno virtual llamado venv

python -m venv venv

# Activar el entorno (en Windows)

venv\Scripts\activate

# Activar el entorno (en Mac/Linux)

source venv/bin/activate

Paso 3: Instalar Flask y Flask-RESTful

Ejecuta el siguiente comando para instalar Flask y Flask-RESTful:

pip install Flask Flask-RESTful

1 2	pip install Flask Flask-RESTful

Para verificar la instalación:

pip show Flask
pip show Flask-RESTful

pip show Flask

pip show Flask-RESTful

Ahora tienes todo listo.

2. Primeros Pasos con Flask: Rutas y Métodos HTTP

Una API RESTful utiliza rutas (endpoints) y métodos HTTP para interactuar con los datos.

Crear la estructura básica de la aplicación

Crea un archivo llamado app.py con el siguiente contenido:

from flask import Flask, request, jsonify

app = Flask(__name__)

# Ruta principal
@app.route('/', methods=['GET'])
def home():
    return "¡Hola! Esta es nuestra primera API con Flask."

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

from flask import Flask, request, jsonify

app = Flask(__name__)

# Ruta principal

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

def home():

return "¡Hola! Esta es nuestra primera API con Flask."

if __name__ == '__main__':

app.run(debug=True)

Para ejecutar la app:

python app.py

1 2	python app.py

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

Explicación

@app.route: Define una ruta o endpoint.
methods=['GET']: Este endpoint solo responde a peticiones GET.
app.run(debug=True): Ejecuta la app con modo debug para desarrollo.

Probemos otros métodos HTTP

Flask soporta los métodos HTTP comunes usados en APIs:

Puedes modificar la ruta para aceptar otros métodos; por ejemplo:

@app.route('/saludo', methods=['POST'])
def saludo_post():
    data = request.get_json()  # Obtener datos JSON enviados
    nombre = data.get('nombre', 'invitado')
    return jsonify({'mensaje': f'Hola, {nombre}!'}), 201

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

def saludo_post():

data = request.get_json() # Obtener datos JSON enviados

nombre = data.get('nombre', 'invitado')

return jsonify({'mensaje': f'Hola, {nombre}!'}), 201

Con esto, cuando envíes un POST con JSON { "nombre": "Juan" }, la respuesta será un saludo personalizado.

3. Manejo de Datos en Formato JSON

El formato estándar para APIs es JSON. Veamos cómo enviar y recibir JSON en Flask.

Enviando JSON de respuesta

Utiliza jsonify() para devolver respuestas JSON:

@app.route('/producto', methods=['GET'])
def obtener_producto():
    producto = {
        'id': 1,
        'nombre': 'Laptop',
        'precio': 1200
    }
    return jsonify(producto)

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

def obtener_producto():

producto = {

'id': 1,

'nombre': 'Laptop',

'precio': 1200

}

return jsonify(producto)

Recibiendo JSON en las peticiones

Desde el cliente puedes enviar datos en JSON con POST o PUT, y acceder a ellos con request.get_json():

@app.route('/producto', methods=['POST'])
def crear_producto():
    data = request.get_json()
    # Suponemos que la data contiene 'nombre' y 'precio'
    nombre = data.get('nombre')
    precio = data.get('precio')

    producto = {
        'id': 2,  # idéntico en este ejemplo
        'nombre': nombre,
        'precio': precio
    }
    return jsonify(producto), 201

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

def crear_producto():

data = request.get_json()

# Suponemos que la data contiene 'nombre' y 'precio'

nombre = data.get('nombre')

precio = data.get('precio')

producto = {

'id': 2, # idéntico en este ejemplo

'nombre': nombre,

'precio': precio

}

return jsonify(producto), 201

Para probar esto puedes usar herramientas como Postman o cURL:

curl -X POST http://127.0.0.1:5000/producto \
-H "Content-Type: application/json" \
-d '{"nombre": "Mouse", "precio": 25}'

curl -X POST http://127.0.0.1:5000/producto \

-H "Content-Type: application/json" \

-d '{"nombre": "Mouse", "precio": 25}'

4. Usando Flask-RESTful para Simplificar el Desarrollo

Flask-RESTful facilita la creación de APIs con clases y gestión automática de rutas.

Paso 1: Importar y crear API

Modifica tu archivo app.py así:

from flask import Flask, request
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)

class HolaMundo(Resource):
    def get(self):
        return {'mensaje': '¡Hola, mundo desde Flask-RESTful!'}

api.add_resource(HolaMundo, '/')

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

from flask import Flask, request

from flask_restful import Resource, Api

app = Flask(__name__)

api = Api(app)

class HolaMundo(Resource):

def get(self):

return {'mensaje': '¡Hola, mundo desde Flask-RESTful!'}

api.add_resource(HolaMundo, '/')

if __name__ == '__main__':

app.run(debug=True)

Aquí estamos definiendo una clase HolaMundo que maneja el método GET para la ruta /.

Paso 2: Crear un recurso con métodos CRUD

Vamos a simular una lista de productos en memoria:

productos = [
    {'id': 1, 'nombre': 'Laptop', 'precio': 1200},
    {'id': 2, 'nombre': 'Mouse', 'precio': 25}
]

class Producto(Resource):
    def get(self, producto_id):
        producto = next((p for p in productos if p['id'] == producto_id), None)
        if producto:
            return producto
        return {'mensaje': 'Producto no encontrado'}, 404

    def put(self, producto_id):
        data = request.get_json()
        producto = next((p for p in productos if p['id'] == producto_id), None)
        if producto:
            producto['nombre'] = data.get('nombre', producto['nombre'])
            producto['precio'] = data.get('precio', producto['precio'])
            return producto, 200
        return {'mensaje': 'Producto no encontrado'}, 404

    def delete(self, producto_id):
        global productos
        productos = [p for p in productos if p['id'] != producto_id]
        return {'mensaje': 'Producto eliminado'}, 200

class ListaProductos(Resource):
    def get(self):
        return productos

    def post(self):
        data = request.get_json()
        nuevo_id = max(p['id'] for p in productos) + 1 if productos else 1
        nuevo_producto = {
            'id': nuevo_id,
            'nombre': data['nombre'],
            'precio': data['precio']
        }
        productos.append(nuevo_producto)
        return nuevo_producto, 201

api.add_resource(ListaProductos, '/productos')
api.add_resource(Producto, '/productos/<int:producto_id>')

productos = [

{'id': 1, 'nombre': 'Laptop', 'precio': 1200},

{'id': 2, 'nombre': 'Mouse', 'precio': 25}

]

class Producto(Resource):

def get(self, producto_id):

producto = next((p for p in productos if p['id'] == producto_id), None)

if producto:

return producto

return {'mensaje': 'Producto no encontrado'}, 404

def put(self, producto_id):

data = request.get_json()

producto = next((p for p in productos if p['id'] == producto_id), None)

if producto:

producto['nombre'] = data.get('nombre', producto['nombre'])

producto['precio'] = data.get('precio', producto['precio'])

return producto, 200

return {'mensaje': 'Producto no encontrado'}, 404

def delete(self, producto_id):

global productos

productos = [p for p in productos if p['id'] != producto_id]

return {'mensaje': 'Producto eliminado'}, 200

class ListaProductos(Resource):

def get(self):

return productos

def post(self):

data = request.get_json()

nuevo_id = max(p['id'] for p in productos) + 1 if productos else 1

nuevo_producto = {

'id': nuevo_id,

'nombre': data['nombre'],

'precio': data['precio']

}

productos.append(nuevo_producto)

return nuevo_producto, 201

api.add_resource(ListaProductos, '/productos')

api.add_resource(Producto, '/productos/<int:producto_id>')

Cómo funciona:

/productos GET: Lista todos los productos
/productos POST: Crea un producto nuevo
/productos/<producto_id> GET: Obtiene un producto específico
/productos/<producto_id> PUT: Actualiza un producto
/productos/<producto_id> DELETE: Elimina un producto

Prueba estas rutas con Postman o cURL para familiarizarte.

5. Buenas prácticas para desarrollar APIs con Flask

Usa entornos virtuales para manejar dependencias.
Documenta tus endpoints con comentarios o herramientas como Flask-RESTX.
Valida los datos de entrada para evitar errores o vulnerabilidades.
Maneja adecuadamente los códigos HTTP (ejemplo: 200, 201, 404).
Estructura tu proyecto en varios archivos para mantener el código ordenado.
Usa herramientas de testing para probar tu API.

Conclusión: ¡Tu API RESTful con Flask está lista para crecer!

En este tutorial has aprendido cómo configurar un entorno, crear rutas básicas y trabajar con métodos HTTP para construir una API RESTful en Python usando Flask y Flask-RESTful. Está es la base para crear aplicaciones backend robustas y escalables.

¿Qué sigue?

Integra una base de datos como SQLite o PostgreSQL
Agrega autenticación y autorización
Implementa testing automatizado

¡No pares de practicar y mejorar tus APIs!

Si te gustó este tutorial, comparte y comenta tus avances o dudas. ¡Feliz programación con Flask!