¿Cómo crear dependencias personalizadas y middleware en FastAPI?

FastAPI permite trabajar con dependencias de manera eficiente, lo que facilita la creación de funcionalidades que pueden ser reutilizadas en diferentes partes de la aplicación. Las dependencias permiten modularizar y separar las responsabilidades de los diferentes componentes del sistema. Un ejemplo común de uso de dependencias en FastAPI es la creación de clases que agrupan parámetros específicos para luego utilizarlas en los endpoints de la aplicación.

Para crear una dependencia que agrupe estos parámetros, podemos proceder de la siguiente manera. En primer lugar, definimos una clase que contenga todos los parámetros necesarios, como el rango de tiempo, la categoría y el código. Luego, esta clase se utiliza como dependencia en el endpoint correspondiente.

Por ejemplo, al crear una clase FilterParams, podemos agrupar todos los parámetros necesarios y luego inyectar esta clase en el endpoint:

python
Copy code
from fastapi import Depends

class FilterParams:
    def __init__(self, time_range: str = 'all', category: str = 'general', code: str = ''):
        self.time_range = time_range
        self.category = category
        self.code = code
@app.get("/items")
async def get_items(filters: FilterParams = Depends(FilterParams)):

    return {"time_range": filters.time_range, "category": filters.category, "code": filters.code}

Con esto, el endpoint ahora recibe todos los parámetros necesarios como parte de un solo objeto, lo que mejora la claridad y la estructura del código.

Por otro lado, FastAPI también permite la creación de middleware personalizado. El middleware es un componente de la API que intercepta y modifica tanto las solicitudes entrantes como las respuestas salientes. Este enfoque es útil cuando necesitamos implementar funciones transversales, como autenticación, manejo de errores, o incluso análisis de tráfico.

La creación de un middleware personalizado en FastAPI es sencilla y se puede lograr creando una clase que herede de BaseHTTPMiddleware de la librería Starlette. Esta clase debe definir el método dispatch, que intercepta las solicitudes antes de que lleguen a los controladores de los endpoints. A continuación se muestra un ejemplo básico de cómo implementar un middleware que registra la dirección IP del cliente y el método HTTP utilizado:

python
Copy code
from fastapi import Request

from starlette.middleware.base import BaseHTTPMiddleware
import logging
logger = logging.getLogger("uvicorn.error")
class ClientInfoMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        host_client = request.client.host
        requested_path = request.url.path
        method = request.method

        logger.info(f"host client {host_client} requested {method} {requested_path} endpoint")

        return await call_next(request)

Una vez que la clase del middleware está definida, simplemente se añade a la aplicación de FastAPI mediante el método add_middleware. Así, cada vez que se reciba una solicitud, el middleware registrará información sobre el cliente.

Es importante entender que el uso de middleware no se limita a la simple captura de información; se pueden añadir funciones más complejas, como redireccionar solicitudes basadas en la IP del cliente o incluso bloquear ciertas direcciones IP. Esto ofrece un gran potencial para personalizar el comportamiento de la aplicación.

En términos de localización e internacionalización (i18n y l10n), FastAPI también proporciona herramientas que facilitan la adaptación de las aplicaciones a diferentes idiomas y regiones. La localización permite que una aplicación sea adaptada para mercados específicos, como ajustar el formato de fechas, la moneda o las unidades de medida. Por ejemplo, el encabezado Accept-Language en las solicitudes HTTP se utiliza para indicar el idioma preferido del cliente, y con esta información podemos ofrecer contenido en el idioma adecuado.

Para implementar la internacionalización y localización en FastAPI, se puede hacer uso del encabezado Accept-Language que los navegadores envían automáticamente. En función de este encabezado, podemos determinar el idioma preferido por el usuario y ofrecer el contenido correspondiente. Además, se pueden usar bibliotecas como Babel para gestionar los códigos de idioma y realizar las conversiones necesarias.

Por ejemplo, se puede crear un sistema de selección de idioma que permita servir contenido en inglés estadounidense (en_US) o en francés (fr_FR), dependiendo de la preferencia del usuario. Para manejar este proceso, basta con capturar el encabezado Accept-Language y devolver el idioma adecuado según los códigos establecidos:

python
Copy code
from fastapi import Request

from babel import Locale
SUPPORTED_LANGUAGES = ['en_US', 'fr_FR']
def get_language(request: Request):
    language = request.headers.get('Accept-Language', 'en_US')
    if language not in SUPPORTED_LANGUAGES:
        language = 'en_US'  # Valor predeterminado
    return Locale.parse(language)

Además de gestionar los idiomas, FastAPI también permite personalizar la respuesta según el locale. Esto implica adaptar la respuesta a las preferencias del usuario en cuanto a formato de fechas, números o incluso mensajes.

Es crucial que, al trabajar con i18n y l10n, no solo se enfoque en el contenido textual, sino también en las implicaciones culturales y las expectativas regionales. Esto puede incluir adaptaciones en la forma en que se muestran los precios, las unidades de medida o incluso las normas de comportamiento dentro de la interfaz de usuario.

¿Cómo asegurar un WebSocket con OAuth2 en FastAPI?

Para ello, uno de los primeros pasos es definir un esquema de autenticación con OAuth2 específicamente para WebSockets. Este se puede lograr mediante un objeto como oauth2_scheme_for_ws, que se puede configurar a partir de la clase OAuth2WebSocketPasswordBearer, que facilita la gestión del token de autenticación para las conexiones WebSocket. Este objeto se define de la siguiente manera:

python
Copy code
from app.ws_password_bearer import OAuth2WebSocketPasswordBearer

oauth2_scheme_for_ws = OAuth2WebSocketPasswordBearer(
    tokenUrl="/token"
)

Aquí, el argumento tokenUrl señala la dirección del endpoint que será responsable de devolver el token de acceso. Este token debe ser obtenido a través de un proceso de autenticación previamente establecido, el cual puede implicar el uso de una base de datos o algún servicio externo de autenticación.

python
Copy code
def get_username_from_token(
    token: str = Depends(oauth2_scheme_for_ws),
) -> str:
    user = fake_token_resolver(token)
    if not user:
        raise WebSocketException(
            code=status.HTTP_401_UNAUTHORIZED,
            reason="Invalid authentication credentials"
        )
    return user.username

La función fake_token_resolver es un ejemplo de simulación del proceso de resolución de un token. En el código proporcionado, se utilizan solo dos usuarios ficticios, johndoe y janedoe, para efectos de prueba. Este método no proporciona una seguridad real y se utiliza solo como un ejemplo de cómo el flujo de autenticación debería funcionar en un entorno de desarrollo. Para una implementación en un entorno de producción, se recomienda utilizar un sistema de tokens JWT o integrar un proveedor externo de autenticación, como se menciona en los capítulos sobre autenticación y autorización.

Una vez configurada esta parte de la autenticación, el siguiente paso es integrar la validación del token con el endpoint de WebSocket seguro. El código para esto es el siguiente:

python
Copy code
from fastapi import Depends

from app.security import get_username_from_token
@app.websocket("/secured-ws")
async def secured_websocket(
    websocket: WebSocket,
    username: Annotated[get_username_from_token, Depends()]
):
    # resto del endpoint

Este fragmento de código asegura que cualquier intento de conexión al WebSocket /secured-ws esté sujeto a una validación de autenticación, garantizando que solo los usuarios con un token válido puedan acceder al recurso.

Cuando un cliente intenta conectarse a este WebSocket usando herramientas como Postman o cualquier otra herramienta de pruebas de WebSockets, se producirá un error de autorización si no se proporciona un token válido. La conexión será rechazada antes de que se realice el "handshake" inicial. Para poder conectar, es necesario obtener un token de acceso y pasarlo como un encabezado en la solicitud WebSocket.

Si el token es válido, la conexión será aceptada y el cliente podrá intercambiar mensajes con el servidor. Así, se asegura que solo aquellos usuarios autenticados y autorizados puedan establecer una conexión segura en el WebSocket.

Además de la implementación básica de autenticación, existen varias prácticas adicionales que pueden ser útiles al trabajar con WebSockets en aplicaciones reales. Por ejemplo, es esencial comprender que, en un entorno de producción, la seguridad no solo debe basarse en tokens de acceso estáticos. Es recomendable que se implementen mecanismos de renovación de tokens y se empleen medidas como la validación de sesión y el manejo de expiración de tokens.

El uso de OAuth2 para proteger WebSockets en aplicaciones FastAPI mejora significativamente la seguridad de la comunicación en tiempo real. Sin embargo, es fundamental que el desarrollador tenga en cuenta aspectos como la gestión adecuada de los tokens, la configuración de un sistema robusto de autenticación y la actualización de las dependencias de seguridad para evitar vulnerabilidades.

En este contexto, también es crucial familiarizarse con la manera en que las cookies y los encabezados HTTP pueden ser manipulados para gestionar sesiones y autorizar el acceso a los recursos. Por ejemplo, se puede crear una funcionalidad de chat donde los usuarios deben iniciar sesión para poder participar. En este caso, el endpoint que devuelve la página HTML debe verificar la presencia del token en las cookies del navegador. Si no se encuentra un token válido, el sistema debe redirigir al cliente a una página de inicio de sesión que permita poner el token en las cookies del navegador.

Al integrar OAuth2 en WebSockets, se proporciona una capa adicional de seguridad que protege contra los accesos no autorizados y asegura la integridad de las comunicaciones en tiempo real dentro de las aplicaciones FastAPI.