ProgramaciónPythonFastApi con Python

FastApi con Python

¿Qué es FastAPI?

FastAPI es un framework moderno, rápido (alto rendimiento) para la construcción de APIs con Python 3.7+ basado en las notaciones de tipos (type hints) de Python.

Caracteristicas

  • Basado en estándares
  • Rápido
  • Menos errores
  • Fácil e intuitivo
  • Robusto

Marco utilizado por FastAPI

  • Starlette
  • Pydantic
  • Uvicorn

Cómo crear un entorno virtual en Python (paso a paso) usando Visual Studio Code

  1. Abrir Visual Studio Code y abrir la carpeta de tu proyecto o crear una nueva.
  2. Abrir la terminal integrada en VSCode: ve al menú superior y selecciona Terminal > Nuevo Terminal.
  3. Crear el entorno virtual escribiendo el siguiente comando en la terminal (reemplaza nombre_entorno por el nombre que quieras darle):
python -m venv nombre_entorno

Esto crea una carpeta con el entorno virtual dentro de tu proyecto.

  1. Activar el entorno virtual (en Windows)
nombre_entorno\\Scripts\\activate
  1. Instalar paquetes en el entorno virtual con pip, por ejemplo:
pip install nombre_paquete

pip install fastapi uvicorn

Uvicorn es un servidor web para Python que implementa el estándar ASGI (Asynchronous Server Gateway Interface). Su principal función es ejecutar aplicaciones web escritas con frameworks asíncronos como FastAPI o Starlette.

Sirve para correr la aplicación Python y manejar las solicitudes HTTP de forma eficiente, aprovechando programación asíncrona para que pueda atender múltiples conexiones simultáneamente, con mejor rendimiento en comparación con los servidores WSGI tradicionales. Además, Uvicorn es muy rápido y ligero.

  1. Para desactivar el entorno virtual cuando termines, usa:
deactivate

Creación de primera aplicación

  1. Seleccionar las teclas Ctrl + Shift + P
  2. Escribe Python: Select Interpreter
  3. Selecciona tu entorno virtual de la lista (el que creaste para FastAPI)
fastapi_001
  1. Si no aparece, usa Enter interpreter path… para ubicarlo manualmente
  2. Confirma que en la barra inferior derecha aparece el entorno seleccionado

Así tu entorno virtual estará activo para que puedas ejecutar y depurar tu aplicación FastAPI correctamente en VSCode

from fastapi import FastAPI

app = FastAPI()

@app.get('/')
def home():
    return "Hola Mundo!"

Para ejecutar la aplicación se ejecuta el comando

uvicorn main:app

Por defecto la aplicación se ejecuta en el puerto 8000, si queremos que use un puerto distinto debemos usar el comando

uvicorn main:app --port 5000 (usa el port que quieras)

Si queremos que se muestres los cambios realizados en la aplicación a la hora de ejecutar la aplicación debemos usar el comando

uvicorn main:app --port 5000 --reload

Si queremos ejecutar nuestra aplicación en red es decir que pueda ser accedida por otros dispositivos que estén conectados a la misma red, debemos ejecutar el comando

uvicorn main:app --host 0.0.0.0 --port 5000 --reload
Documentación automática

FastAPI integra automáticamente una documentación de cada uno de los endpoints que contiene nuestra aplicación para esto se basa en los estándares de Open API los cuales son una especificación abierta para definir y describir una API Rest.

Para ver la documentación en la URL 127.0.0.1:8000 añadimos /docs (http://127.0.0.1:8000/docs)

fastapi_002

Otra documentación disponible es redoc 127.0.0.1:8000/redoc

fastapi_003

Uso de metodo GET

El método GET en FastAPI se utiliza para recuperar información de un recurso específico sin modificarlo. Es el método HTTP más común y debe ser idempotente, es decir, realizar la misma operación varias veces produce siempre el mismo resultado sin efectos secundarios.

Para implementar un endpoint GET en FastAPI, se usa el decorador @app.get("ruta") encima de una función que maneje la petición. Cuando un cliente (navegador, aplicación, etc.) hace una solicitud GET a esa ruta, FastAPI ejecuta la función y devuelve la respuesta, usualmente en formato JSON.

Un ejemplo básico sería:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def leer_raiz():
    return {"mensaje": "¡Hola desde FastAPI!"}

En este ejemplo, la función leer_raiz responde con un diccionario simple cuando un usuario accede a la ruta raíz /.

Se pueden crear rutas específicas para distintos recursos, con funciones descriptivas. Por ejemplo:

@app.get("/usuarios")
def obtener_usuarios():
    return {"usuarios": ["Ana", "Carlos", "María"]}

@app.get("/productos")
def obtener_productos():
    return {"productos": ["Laptop", "Mouse", "Teclado"]}

Cada función responde a solicitudes GET en esas rutas específicas, devolviendo los datos indicados.

Además, FastAPI permite recibir parámetros en rutas dinámicas para obtener datos específicos, como /items/{item_id}, donde item_id es un parámetro que se pasa a la función para buscar un recurso particular.

Podemos importar

from fastapi.responses import HTMLResponse

La instrucción from fastapi.responses import HTMLResponse se usa para importar la clase HTMLResponse de FastAPI, que permite devolver contenido en formato HTML directamente desde un endpoint de tu API.

Parámetros de Ruta

En FastAPI, los parámetros de ruta (o parámetros path) son partes variables que se colocan dentro de la URL entre llaves {}, y que permiten capturar valores directamente desde la ruta para usarlos luego en la función del endpoint.

Para definir un parámetro de ruta, simplemente lo incluyes en la ruta declarada con llaves y luego lo agregas como argumento en la función que maneja la petición. Por ejemplo:

from fastapi import FastAPI

app = FastAPI()

@app.get("/usuarios/{usuario_id}")
async def leer_usuario(usuario_id: int):
    return {"usuario_id": usuario_id}

Aquí, usuario_id es un parámetro de ruta que se espera sea un entero. Si visitas /usuarios/123, FastAPI entregará {"usuario_id": 123}. FastAPI valida y convierte automáticamente el tipo del parámetro según la anotación (en este caso, int) y devolverá un error si no se puede convertir

Parámetros Query

Los parámetros Query en FastAPI son los parámetros que se incluyen en la URL después del signo de interrogación ?, usados comúnmente para enviar información adicional a un endpoint, como filtros, paginación o búsqueda.

Para usarlos en FastAPI, se declaran como parámetros de la función del endpoint que no formen parte de la ruta, y pueden tener valores por defecto para hacerlos opcionales o no tenerlos para que sean obligatorios.

Por ejemplo básico:

from fastapi import FastAPI

app = FastAPI()

fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]

@app.get("/items/")
async def read_items(skip: int = 0, limit: int = 10):
    return fake_items_db[skip : skip + limit]

Aquí, skip y limit son parámetros de consulta (query parameters). Si haces una petición a /items/?skip=1&limit=2, te devolverá los elementos correspondientes saltando el primero y limitando a dos. Si no envías esos parámetros, usará los valores por defecto.

Características clave:

  • Son opcionales si tiene valor por defecto, y obligatorios si no se asigna valor por defecto.
  • FastAPI convierte y valida automáticamente tipos (ejemplo: int, float, bool, str).
  • Se pueden usar para pasar múltiples valores con listas.
  • Permiten definir reglas de validación y metadatos usando Query().

Ejemplo con validación y parámetros opcionales:

from fastapi import FastAPI, Query
from typing import List, Optional

app = FastAPI()

@app.get("/items/")
async def read_items(
    q: Optional[str] = Query(None, max_length=50),
    skip: int = Query(0, ge=0),
    limit: int = Query(10, le=100),
    tags: List[str] = Query([])
):
    return {"q": q, "skip": skip, "limit": limit, "tags": tags}
  • q: parámetro opcional con límite máximo de longitud.
  • skip: entero mayor o igual que 0.
  • limit: entero menor o igual que 100.
  • tags: lista de cadenas para múltiples valores (/items/?tags=foo&tags=bar).

Si un parámetro obligatorio no se incluye en la solicitud, FastAPI devuelve un error 422.

Estos parámetros son ideales para filtrar, paginar, ordenar o hacer búsquedas en tu API sin complicaciones.

Built with LogoFlowershow