FastAPI es un framework web moderno de alto rendimiento para construir APIs con Python 3.7+ basado en indicaciones de tipo estándar de Python. Ofrece varias ventajas:
- Alto Rendimiento: FastAPI está diseñado para la velocidad, aprovechando la programación asíncrona para manejar miles de peticiones por segundo.
- Documentación Automática: Genera automáticamente documentación interactiva de la API utilizando Swagger UI y ReDoc.
- Verificación de Tipos: FastAPI utiliza las indicaciones de tipo de Python para proporcionar validación y serialización automática de datos.
Aquí se muestra cómo hacer una aplicación FastAPI:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
FastAPI en la Pila Web
Imagina navegar por el bullicioso panorama web con FastAPI como tu guía de confianza. Nuestro diagrama de visión general (figura 1) presenta una vista clara y atractiva de cómo FastAPI se integra perfectamente en la pila web.
En la parte superior, tienes las peticiones del cliente: estas son las interacciones cotidianas de los usuarios que buscan acceder a tu aplicación. FastAPI interviene como el puente dinámico entre estas peticiones y tu servidor. Está diseñado para manejar los datos entrantes de forma rápida y eficiente, asegurando que cada interacción sea fluida y receptiva.
Debajo de la aplicación FastAPI, encontrarás un proceso optimizado donde ocurre la magia. FastAPI es conocido por su velocidad y rendimiento, procesando las peticiones con la velocidad y precisión de un rayo. Es como tener un asistente de primer nivel que no solo entiende tus necesidades, sino que también las anticipa, entregando respuestas en tiempo récord.
Finalmente, la figura 1 muestra cómo las respuestas regresan a los clientes. FastAPI asegura que estas respuestas no solo sean rápidas, sino también altamente fiables, mejorando la experiencia general del usuario.
Por lo tanto, si estás buscando una solución potente, eficiente y fácil de usar para elevar tus aplicaciones web, FastAPI es tu opción ideal. Sumérgete en el diagrama y observa cómo FastAPI puede transformar tu pila web con sus excepcionales capacidades.
Visión General de la Invocación de Endpoints
La invocación de endpoints se refiere al proceso de enviar una petición a un endpoint de API específico para ejecutar una acción definida. En FastAPI, esto implica definir rutas y manejar las peticiones entrantes.
Creación de Endpoints:
En FastAPI, defines los endpoints utilizando decoradores. Cada decorador corresponde a un método HTTP y una ruta URL.
Así es como funciona: from fastapi import FastAPI
from fastapi import FastAPI
app = FastAPI()
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
Esta configuración permite a los usuarios solicitar elementos específicos por su ID, y tu aplicación entrega rápidamente la información que buscan en un formato JSON ordenado;
- @app.get(“/items/{item_id}”) define un endpoint GET donde item_id es un parámetro de ruta.
- La función read_item maneja la petición y devuelve una respuesta JSON.
Imagínate esto: una petición viajando a través de tu aplicación, y nuestro diagrama de endpoints (figura 2) es como un mapa que muestra su aventura.
Primero, una petición se dirige hacia un endpoint, donde es recibida e inicia su viaje. Imagina esto como una puerta de bienvenida donde la petición se prepara y está lista. A continuación, nos sumergimos en los parámetros. Estos son como las instrucciones o detalles especiales que guían la petición en su camino, asegurando que llegue exactamente a donde necesita ir.
Una vez que la petición tiene todos sus detalles ordenados, se encuentra con la etapa de manejo de la petición. Piensa en esto como el núcleo de la acción, donde la petición se procesa y se realizan todas las operaciones necesarias para obtener los resultados correctos.
Finalmente, la petición llega al final de su viaje con una respuesta. Esto es como el destino final donde los resultados de la petición se empaquetan cuidadosamente y se envían de vuelta a donde todo comenzó.
Por lo tanto, la figura 2 no es solo un diagrama de flujo, es una historia visual de cómo cada petición viaja a través de tu sistema, recibiendo el tratamiento adecuado y regresando con la respuesta perfecta.
Importancia del Registro en APIs
El registro es crucial para la monitorización, depuración y mantenimiento de las APIs. Ayuda a los desarrolladores a:
- Rastrear Peticiones y Respuestas: Entender cómo se está utilizando la API y solucionar problemas.
- Monitorizar el Rendimiento: Identificar cuellos de botella en el rendimiento y optimizar la API.
- Auditoría y Seguridad: Mantener registros del uso de la API para auditorías de cumplimiento y seguridad.
Así es como funciona:
Puedes utilizar el módulo de registro integrado de Python para añadir registro a tu aplicación FastAPI:
import logging
from fastapi import FastAPI
app = FastAPI()
# Configure logging
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
logger.info(f"Received request for item_id: {item_id} with query: {q}")
return {"item_id": item_id, "q": q}
Profundicemos en cómo funciona el registro con esta configuración.
Primero, logging.basicConfig es como establecer las reglas de cómo quieres manejar tus registros. Es donde decides cosas como dónde van tus registros y cómo deben formatearse. Piensa en ello como configurar tu kit de herramientas de registro para que todo esté en su lugar para capturar información importante.
A continuación, tenemos logger.info. Aquí es donde ocurre la magia. Cuando llamas a logger.info, estás añadiendo un mensaje informativo a tus registros. En este caso, se trata de registrar detalles sobre una petición. Es como tomar notas sobre lo que está sucediendo, para que tengas un registro de ello para futuras referencias.
Ahora, pasemos al diagrama de flujo de registro (figura 3). Este diagrama es como una guía visual que muestra cómo se registra una petición de principio a fin. Mapea el viaje, desde la configuración de tu configuración de registro hasta la captura y el registro del mensaje. Es una forma práctica de ver cómo todas las piezas se unen para realizar un seguimiento de las actividades de tu aplicación.
Configuración de FastAPI para Endpoints de la Versión 2
¡Bienvenido al mundo de FastAPI! Si estás ansioso por aprovechar el poder de uno de los frameworks más rápidos para construir APIs con Python, estás en el lugar correcto. Ya sea que estés actualizando tus APIs existentes a la versión 2 o comenzando de nuevo, esta guía te guiará a través de todo lo que necesitas para comenzar. Desde la instalación de FastAPI y Uvicorn hasta la configuración de la estructura de tu proyecto y la creación de una aplicación básica, te tenemos cubierto. ¡Vamos a sumergirnos!
1. Instalación de FastAPI y Uvicorn
¿Por qué FastAPI? FastAPI es reconocido por su velocidad, simplicidad y características modernas. Es perfecto para construir APIs que sean rápidas y fáciles de mantener.
¿Por qué Uvicorn? Uvicorn es un servidor ASGI de alto rendimiento que es ideal para ejecutar aplicaciones FastAPI. Soporta operaciones asíncronas, lo que lo convierte en una gran opción para aplicaciones escalables.
Empezando:
Para instalar FastAPI y Uvicorn, simplemente ejecuta:pip install fastapi uvicorn
Características a Destacar:
- FastAPI: Permite la documentación interactiva automática, la validación y el soporte asíncrono.
- Uvicorn: Actúa como un servidor ASGI de alta velocidad, perfecto para entornos de desarrollo y producción.
Imagina que estás configurando tu entorno de desarrollo y quieres ver cómo encaja todo. El Diagrama de Flujo de Instalación (figura 4) es como un mapa que te muestra exactamente cómo FastAPI y Uvicorn se unen para que tu aplicación web funcione sin problemas.
Piensa en FastAPI como el potente framework de API que maneja toda la magia detrás de las peticiones y respuestas de tu aplicación. Es como el cerebro de tu aplicación, procesando datos y gestionando interacciones.
Ahora, Uvicorn es el servidor que da vida a FastAPI. Es el motor fiable que se ejecuta entre bastidores, asegurando que FastAPI maneje las peticiones entrantes y entregue las respuestas de manera eficiente.
Este diagrama te ayuda a visualizar cómo FastAPI y Uvicorn interactúan dentro de tu configuración de desarrollo. Muestra la relación entre ellos y cómo encajan en la imagen más grande de tu servidor y framework de aplicación. Es una forma práctica de entender el flujo y ver cómo cada pieza contribuye al conjunto.
2. Estructura del Proyecto y Dependencias
¿Por qué Organizar Tu Proyecto? Un proyecto bien estructurado no solo ayuda a mantener y escalar tu aplicación, sino que también asegura que la colaboración con otros sea fluida y eficiente.
Cómo Configurar:
1. Crea el Directorio del Proyecto: Organiza los archivos de tu proyecto en directorios.
2. Define las Dependencias: Utiliza requirements.txt para listar todos los paquetes, facilitando su instalación con:pip install -r requirements.txt
Piensa en el Diagrama de Estructura del Proyecto (figura 5) como un plano para tu base de código. Es como un mapa detallado que te muestra cómo está organizado todo en tu proyecto.
Imagina que estás configurando un nuevo proyecto y necesitas averiguar dónde colocar diferentes piezas como endpoints, modelos y esquemas. Este diagrama facilita ver dónde debe ir cada parte.
Es como tener un archivador bien organizado donde sabes exactamente qué cajón abrir para tus endpoints de API, dónde archivar tus modelos de datos y dónde guardar tus esquemas. Al visualizar la estructura, puedes entender rápidamente cómo encajan todos los componentes y mantener tu proyecto ordenado y manejable.
• app/main.py: El corazón de tu aplicación FastAPI.
• app/api/v2/endpoints.py: Donde definirás tus endpoints de la versión 2.
• requirements.txt: Un archivo que lista todas las dependencias para tu proyecto.
3. Creación de una Aplicación FastAPI Básica
¿Por qué Empezar Simple? Una aplicación simple y funcional sienta las bases para añadir características más complejas. Asegura que entiendas los componentes centrales de FastAPI antes de profundizar.
Cómo funciona la Aplicación Básica:
# app/main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Welcome to FastAPI!"}
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "query": q}
Ejecutando Tu Aplicación:
Para ver tu aplicación FastAPI en acción, ejecuta:
uvicorn app.main:app --reload
Visita http://127.0.0.1:8000 en tu navegador, y verás tu API en acción. No olvides consultar la documentación interactiva de la API en:
Características a Destacar:
• Documentación Interactiva: Generada automáticamente y accesible a través de /docs y /redoc.
• Soporte Asíncrono: FastAPI permite una alta concurrencia con operaciones asíncronas.
Imagina que estás rastreando una petición mientras viaja a través de tu aplicación FastAPI. El Diagrama de Flujo de la Aplicación Básica ilustrado en la figura 6 es como una guía paso a paso que muestra este viaje en acción.
Así es como funciona: entra una petición, y el diagrama muestra exactamente cómo se procesa. Primero, tu aplicación FastAPI recibe la petición: piensa en ello como el punto de partida donde tu aplicación da la bienvenida a los datos entrantes.
A continuación, el diagrama describe el viaje de esta petición a medida que se maneja. Esto incluye cualquier procesamiento, interacciones con bases de datos o cualquier otra operación que realice tu aplicación.
Finalmente, muestra cómo la aplicación envuelve todo y envía una respuesta de vuelta. Es como rastrear un paquete desde el momento en que llega al almacén hasta que se entrega al cliente.
Configurar FastAPI para endpoints de la versión 2 es muy fácil y definitivamente vale la pena. Con las potentes características de FastAPI y la velocidad de Uvicorn, estarás construyendo APIs eficientes y escalables en poco tiempo.
Mejorando el Registro con Endpoints de la Versión 2
Cuando se trata de construir aplicaciones web robustas y escalables, el registro no es solo una característica; es un componente crítico que ayuda en la monitorización, depuración y mantenimiento de la salud de la aplicación. Con FastAPI, puedes aprovechar las capacidades avanzadas de registro para asegurar que tu aplicación funcione sin problemas y que los problemas se aborden rápidamente. En esta guía, te guiaremos a través de la mejora de tu configuración de registro con FastAPI, centrándonos en los endpoints de la Versión 2. ¡Vamos a sumergirnos!
Introducción a las Características de Registro de FastAPI
FastAPI ofrece soporte integrado para el registro, que es esencial para rastrear el comportamiento de la aplicación y diagnosticar problemas. El registro proporciona una forma de registrar eventos, errores y otras ocurrencias significativas en tu aplicación. Esta funcionalidad es crucial para entender el rendimiento de la aplicación y las interacciones del usuario.
Por qué el Registro es Importante:
• Depuración: Identifica y resuelve rápidamente problemas en tu código.
• Monitorización: Realiza un seguimiento de la salud y el rendimiento de la aplicación.
• Auditoría: Registra las acciones del usuario y los cambios del sistema para la seguridad y el cumplimiento.
FastAPI se integra perfectamente con la biblioteca de registro estándar de Python, lo que permite configuraciones de registro flexibles y potentes.
Aquí tienes una visión rápida de cómo encaja el registro con FastAPI:
- Caja de FastAPI: La "Aplicación FastAPI" central se destaca en azul, mostrándola como el corazón de tu configuración.
- Niveles de Registro: INFO (verde), DEBUG (naranja) y ERROR (rojo) son los diferentes niveles de registro, cada uno conectado a FastAPI con flechas.
- Sistema de Registro de Python: Esto está en dorado a la derecha, indicando que maneja todos los mensajes de registro de FastAPI.
La figura 7 te ayuda a ver cómo funciona FastAPI con la biblioteca de registro de Python, ilustrando cómo los diferentes niveles de registro interactúan con tu aplicación.
Configuración de la Configuración de Registro
Configurar el registro en FastAPI implica establecer una configuración de registro que se adapte a tus necesidades. Puedes definir niveles de registro, formatear mensajes y especificar dónde deben salir los registros (consola, archivo, etc.).
Pasos para Configurar el Registro:
- Importa el Módulo de Registro: Utiliza el módulo
loggingde Python para configurar tu configuración. - Define la Configuración de Registro: Establece el nivel de registro, el formato y los manejadores.
- Inicializa el Registro en FastAPI: Aplica la configuración a tu aplicación FastAPI.
Aquí tienes una configuración básica para el registro en FastAPI:
import logging
from fastapi import FastAPI
# Configure logging
logging.basicConfig(level=logging.INFO, # Adjust the level as needed
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[logging.StreamHandler()]) # Logs to console
app = FastAPI()
@app.get("/")
def read_root():
logging.info("Root endpoint accessed")
return {"Hello": "World"}
@app.get("/items/{item_id}")
def read_item(item_id: int):
logging.debug(f"Item requested: {item_id}")
if item_id > 10:
logging.error("Item ID is too high")
return {"item_id": item_id}
Características a Destacar:
• Niveles de Registro: INFO, DEBUG, ERROR: utiliza diferentes niveles para controlar la verbosidad de los registros.
• Manejadores Personalizados: Dirige los registros a archivos, servidores remotos u otros destinos.
• Formato de Mensajes: Personaliza los formatos de los mensajes de registro para incluir marcas de tiempo, niveles de registro, etc.
Aquí tienes un resumen rápido de cómo se configura el registro:
- Configuración de Registro: En la parte superior, una caja dorada muestra dónde ocurre la configuración del registro.
- Componentes de la Aplicación: Tres cajas azules representan diferentes partes de tu aplicación donde se generan los registros.
- Registrador: La caja verde recopila estos registros y los dirige a donde necesitan ir.
- Manejadores: Dos cajas de color rojo-naranja muestran los Manejadores de Archivo y Consola que procesan y formatean los registros.
- Destinos: Las cajas púrpuras a la derecha indican dónde terminan los registros, como archivos de registro o la consola.
Este diagrama de flujo ilustrado en la figura 8 facilita ver cómo los mensajes de registro viajan desde tu aplicación hasta sus destinos finales.
Implementación de Endpoints de la Versión 2 para el Registro
Con FastAPI, los endpoints de la Versión 2 ofrecen capacidades mejoradas para el registro. Puedes construir sobre el registro estándar de FastAPI para implementar estrategias de registro más sofisticadas para tus endpoints.
Consideraciones Clave:
• Registro Estructurado: Utiliza registros estructurados para capturar información detallada y procesable.
• Manejo de Errores Mejorado: Registra información detallada de errores para diagnosticar problemas de manera efectiva.
• Métricas de Rendimiento: Realiza un seguimiento de las métricas de rendimiento, como la duración de la petición y el rendimiento.
Aquí tienes cómo puedes implementar el registro en los endpoints de la Versión 2:
from fastapi import FastAPI, Request
import logging
app = FastAPI()
# Enhanced logging configuration
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[logging.FileHandler("app.log"), logging.StreamHandler()])
@app.post("/log")
async def log_endpoint(request: Request):
body = await request.json()
logging.info(f"Received request with body: {body}")
return {"status": "logged"}
@app.get("/performance")
def performance_metrics():
# Example of logging performance metrics
start_time = logging.datetime.now()
# Simulate processing
logging.info(f"Performance metrics requested at {start_time}")
return {"metrics": "sample_metrics"}
Características a Destacar:
• Registro Asíncrono: Maneja los registros de manera asíncrona para un mejor rendimiento.
• Registro de Archivos: Guarda los registros en un archivo para un almacenamiento persistente.
• Registro de Rendimiento: Captura y analiza las métricas de rendimiento.
Aquí tienes una visión general simple de cómo funciona el registro con tus peticiones:
1.Caja de Petición: Esta caja azul claro es donde comienzan las peticiones entrantes.
2.Tipos de Registro:
• Los registros INFO están en verde.
• Los registros ERROR están en rojo.
• Los registros DEBUG están en dorado.
3.Manejadores: Los registros se mueven a:
• Manejador de Archivo (azul).
• Manejador de Consola (también azul).
4.Destinos: Los registros terminan en:
Archivo de Registro o Consola (púrpura).
La figura 9 muestra cómo las peticiones conducen a diferentes tipos de registro, que luego se manejan y se dirigen a sus destinos finales. Configurar esto correctamente asegura que obtengas información clara y puedas mantener tu aplicación FastAPI funcionando sin problemas.
Características Avanzadas de Registro y Mejores Prácticas
En cualquier aplicación FastAPI, el registro va más allá de simplemente registrar mensajes en una consola. Se trata de construir un sistema robusto que te ayude a rastrear problemas, monitorizar el rendimiento y gestionar errores de manera efectiva. Al aprovechar las características avanzadas de registro y las mejores prácticas, puedes convertir tus registros en una herramienta valiosa para mantener y escalar tu aplicación.
Exploremos algunas de las características más avanzadas del registro en FastAPI, centrándonos en la inyección de dependencias para el registro, la personalización de mensajes de registro y las mejores prácticas para el manejo de excepciones y errores.
Uso de la Inyección de Dependencias para el Registro
La inyección de dependencias en FastAPI es una característica increíblemente potente, y también se extiende al registro. En lugar de configurar el registro por separado en cada función, puedes inyectarlo en tus rutas, haciendo que tu código sea más limpio y más escalable.
¿Por qué Usar la Inyección de Dependencias para el Registro?
• Consistencia: Asegura una configuración de registro consistente en todos los endpoints.
• Reutilización: Te permite definir y utilizar configuraciones de registro de forma centralizada, evitando código redundante.
• Flexibilidad: Facilita la modificación de tu configuración de registro sin cambiar el código de los endpoints individuales.
Aquí tienes cómo puedes inyectar una instancia de registro utilizando la función Depends de FastAPI:
import logging
from fastapi import FastAPI, Depends
app = FastAPI()
# Logging configuration
def get_logger():
logger = logging.getLogger("app_logger")
logger.setLevel(logging.INFO)
if not logger.handlers:
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
logger.addHandler(handler)
return logger
@app.get("/items/")
def read_items(logger=Depends(get_logger)):
logger.info("Items endpoint accessed")
return {"message": "Fetching items"}
Características a Destacar:
• Configuración Centralizada del Registrador: Con la inyección de dependencias, solo defines tu registrador una vez.
• Inyección Automática: FastAPI proporciona automáticamente el registrador a cualquier endpoint que lo necesite.
La figura 10 ilustra el Flujo de Inyección de Dependencias que muestra cómo las peticiones se convierten en registros, cómo se manejan y dónde terminan. Se trata de mantener tu aplicación FastAPI funcionando sin problemas con un registro claro.
Aspectos Clave del diagrama de flujo de inyección de dependencias:
• Petición del Cliente: El punto de partida donde el cliente envía una petición a la aplicación FastAPI.
• Endpoint de FastAPI: Representa el endpoint en FastAPI donde ocurre la inyección de dependencias.
• Registrador Inyectado a través de DI: Muestra que el registrador se inyecta en el endpoint utilizando el mecanismo de inyección de dependencias de FastAPI.
• Registro (Información de la Petición): Registra los detalles de la petición, como el método, la ruta y otra información útil.
• Respuesta de FastAPI: La respuesta devuelta al cliente después de registrar la petición.
Personalización de Mensajes de Registro
La capacidad de personalizar los mensajes de registro es crucial para hacer que tus registros sean informativos y procesables. Los registros predeterminados pueden no siempre proporcionar suficiente contexto, especialmente en entornos de producción. La integración de FastAPI con el módulo de registro de Python facilita la adición de detalles personalizados a tus registros.
Estrategias Clave para Personalizar Mensajes de Registro:
• Añade Información de la Petición: Incluye detalles de la petición como la dirección IP, los encabezados y la ruta.
• Añade Información Contextual: Personaliza los registros para incluir información relevante para el endpoint u operación actual, como las acciones del usuario o los detalles específicos de los recursos.
• Formatea para la Legibilidad: Utiliza registros estructurados o formato JSON para una mejor legibilidad y una integración más fácil con herramientas de registro como la pila ELK.
Aquí tienes cómo personalizar los mensajes de registro con detalles de la petición:
from fastapi import Request
@app.middleware("http")
async def log_requests(request: Request, call_next):
logger = logging.getLogger("custom_logger")
logger.info(f"Incoming request: {request.method} {request.url}")
response = await call_next(request)
logger.info(f"Response status: {response.status_code}")
return response
Características a Destacar:
• Middleware para el Registro: Este middleware registra tanto las peticiones entrantes como las respuestas salientes.
• Información Personalizada: Puedes registrar detalles específicos como el método de la petición, la URL y el estado de la respuesta.
Imagina este Flujo de Registro Personalizado ilustrado en la figura 11 como una guía para rastrear una petición a través de tu sistema. Comienza con la petición moviéndose a través del middleware, donde se registra con detalles personalizados. Luego, a medida que continúa el proceso, también se registra la respuesta. El gráfico destaca los puntos clave donde se añaden esos mensajes de registro personalizados, dándote una visión clara de cómo se rastrea y registra todo.
Manejo de Excepciones y Errores
Cuando ocurren errores en tu aplicación, el registro juega un papel crucial en el rastreo de la causa raíz. Las características de manejo de excepciones de FastAPI, combinadas con el registro, aseguran que captures y registres información detallada sobre los errores sin exponer detalles sensibles a los usuarios.
Mejores Prácticas para el Registro de Excepciones:
• Registra Información Detallada del Error: Captura rastreos de pila, mensajes de error y contexto de la petición.
• Registra Diferentes Niveles de Error: Utiliza niveles de registro apropiados como ERROR o CRITICAL para las excepciones para diferenciarlas de las entradas de registro regulares.
• Evita el Registro Excesivo: Ten en cuenta el registro de información sensible o demasiados detalles que podrían saturar tus registros.
Aquí tienes cómo manejar y registrar excepciones en FastAPI:
from fastapi import HTTPException
import logging
@app.get("/items/{item_id}")
def read_item(item_id: int, logger=Depends(get_logger)):
try:
if item_id > 100:
raise HTTPException(status_code=404, detail="Item not found")
logger.info(f"Item {item_id} fetched successfully")
return {"item_id": item_id}
except HTTPException as e:
logger.error(f"Error fetching item {item_id}: {e.detail}")
raise e
Características a Destacar:
• Registro Estructurado de Excepciones: Registra información detallada cuando ocurre una excepción, incluyendo el ID del elemento y los detalles del error.
• Manejo Elegante de Errores: Lanza excepciones HTTP mientras registra el problema para un análisis posterior.
