Cómo Construir una API con FastAPI en Python

En el mundo del desarrollo web moderno, la creación de APIs (Interfaces de Programación de Aplicaciones) eficientes y rápidas es fundamental. FastAPI se ha posicionado como una de las herramientas más populares y efectivas para lograr este objetivo, especialmente cuando se utiliza con Python. En este artículo, te guiaremos paso a paso sobre cómo construir una API completa utilizando FastAPI, desde la configuración inicial hasta la implementación de endpoints complejos y la creación de un ejemplo práctico. Prepárate para sumergirte en el mundo de FastAPI y descubrir cómo simplificar el desarrollo de tus APIs.

Introducción a FastAPI

FastAPI es un framework web de alto rendimiento para construir APIs con Python 3.6+ basado en las sugerencias de tipo estándar de Python. Sus principales características incluyen:

Velocidad: Gracias a Starlette y Pydantic, FastAPI ofrece un rendimiento comparable a NodeJS y Go.
Facilidad de uso: Su diseño intuitivo y la validación de datos automática simplifican el proceso de desarrollo.
Menos errores: La validación de datos reduce los errores en tiempo de ejecución.
Validación de datos: La validación de datos se realiza con Pydantic.
Documentación automática: Genera documentación interactiva de la API (Swagger UI y ReDoc) automáticamente.

FastAPI es ideal para proyectos que requieren alto rendimiento, desarrollo rápido y documentación clara. Su integración con Pydantic para la validación de datos y su capacidad para generar documentación interactiva hacen que sea una opción muy atractiva para desarrolladores de todos los niveles.

Configuración e Instalación

Antes de comenzar a construir nuestra API, necesitamos configurar nuestro entorno e instalar FastAPI junto con las dependencias necesarias. Sigue estos pasos:

Crear un entorno virtual: Es una buena práctica crear un entorno virtual para aislar las dependencias de nuestro proyecto. Abre tu terminal y ejecuta los siguientes comandos:
```
python3 -m venv venv
  source venv/bin/activate  # En Linux/macOS
  venv\Scripts\activate  # En Windows
```
Instalar FastAPI y Uvicorn: FastAPI necesita un servidor ASGI para funcionar. Uvicorn es una excelente opción. Instala ambos con pip:
```
pip install fastapi uvicorn
```

Una vez completados estos pasos, tu entorno estará listo para empezar a desarrollar con FastAPI. Asegúrate de activar el entorno virtual cada vez que trabajes en el proyecto.

Creación de Endpoints

Los endpoints son la base de cualquier API. En FastAPI, se definen como funciones Python decoradas con métodos HTTP específicos (GET, POST, PUT, DELETE, etc.). Aquí te mostramos cómo crear algunos endpoints básicos:

Crear el archivo `main.py`: Crea un archivo llamado `main.py` donde definiremos nuestra API.

Importar FastAPI:

from fastapi import FastAPI

app = FastAPI()

Crear un endpoint GET: Este endpoint devolverá un mensaje de bienvenida.

@app.get("/")
async def read_root():
 return {"message": "¡Bienvenido a mi API!"}

Crear un endpoint con parámetros: Este endpoint recibirá un parámetro `item_id` y lo devolverá en la respuesta.
```
@app.get("/items/{item_id}")
async def read_item(item_id: int):
 return {"item_id": item_id}
```

Crear un endpoint POST: Este endpoint recibirá datos en el cuerpo de la solicitud y los devolverá.

from pydantic import BaseModel

class Item(BaseModel):
 name: str
 description: str | None = None
 price: float
 tax: float | None = None


@app.post("/items/")
async def create_item(item: Item):
 return item

Para ejecutar la API, utiliza el siguiente comando:

uvicorn main:app --reload

Esto iniciará el servidor Uvicorn y podrás acceder a la API en `http://127.0.0.1:8000`. La documentación interactiva estará disponible en `http://127.0.0.1:8000/docs`.

Ejemplo de API Completa

Para consolidar lo aprendido, vamos a crear una API completa que gestiona una lista de tareas. Esta API permitirá crear, leer, actualizar y eliminar tareas.

Definir el modelo de datos:

from typing import List
from pydantic import BaseModel

class Task(BaseModel):
 id: int
 title: str
 description: str
 completed: bool = False

Inicializar la lista de tareas:

tasks: List[Task] = []
current_id: int = 1

Implementar los endpoints:

Crear una tarea (POST):

@app.post("/tasks/")
async def create_task(task: Task):
 global current_id
 task.id = current_id
 tasks.append(task)
 current_id += 1
 return task

Leer todas las tareas (GET):

@app.get("/tasks/")
async def read_tasks():
 return tasks

Leer una tarea por ID (GET):

@app.get("/tasks/{task_id}")
async def read_task(task_id: int):
 for task in tasks:
 if task.id == task_id:
 return task
 return {"error": "Tarea no encontrada"}

Actualizar una tarea (PUT):

@app.put("/tasks/{task_id}")
async def update_task(task_id: int, updated_task: Task):
 for i, task in enumerate(tasks):
 if task.id == task_id:
 updated_task.id = task_id
 tasks[i] = updated_task
 return updated_task
 return {"error": "Tarea no encontrada"}

Eliminar una tarea (DELETE):

@app.delete("/tasks/{task_id}")
async def delete_task(task_id: int):
 for i, task in enumerate(tasks):
 if task.id == task_id:
 del tasks[i]
 return {"message": "Tarea eliminada"}
 return {"error": "Tarea no encontrada"}

Este ejemplo completo demuestra cómo construir una API funcional con FastAPI, gestionando datos y utilizando diferentes métodos HTTP.

En este artículo, hemos explorado cómo construir una API con FastAPI en Python. Hemos cubierto la configuración inicial, la creación de endpoints y la implementación de una API completa de gestión de tareas. FastAPI se destaca por su velocidad, facilidad de uso y la generación automática de documentación, lo que lo convierte en una excelente opción para desarrollar APIs modernas y eficientes. Esperamos que esta guía te haya proporcionado los conocimientos necesarios para empezar a construir tus propias APIs con FastAPI.