Desbloqueando el poder de la autenticación en FastAPI: Protege tus APIs con facilidad

Ya seas un desarrollador experimentado o estés empezando, asegurar que tus APIs son seguras es crucial. FastAPI, un framework web moderno y rápido (de alto rendimiento) para construir APIs con Python 3.7+, ofrece una excelente solución. Hoy, nos sumergiremos en los entresijos de la autenticación en FastAPI, exploraremos cómo implementarla y por qué es un cambio de juego para tus proyectos. Además, tocaremos cómo herramientas como Apidog pueden hacer tu vida aún más fácil.

button

¿Por qué FastAPI para tus APIs?

Antes de saltar a los detalles de la autenticación, hablemos de por qué podrías elegir FastAPI en primer lugar. FastAPI está diseñado para ser rápido y simple, permitiéndote construir y desplegar APIs de alto rendimiento rápidamente. Está construido sobre Starlette para las partes web y Pydantic para las partes de datos, lo que significa que obtienes tanto velocidad como fiabilidad.

Framework FastAPI, alto rendimiento, fácil de aprender, rápido de codificar, listo para producción

Beneficios Clave de FastAPI

Rendimiento: FastAPI es uno de los frameworks de Python más rápidos disponibles.
Facilidad de Uso: Su sintaxis es intuitiva y directa, haciéndolo accesible incluso para principiantes.
Documentación Automática e Interactiva de la API: FastAPI genera automáticamente documentación interactiva de la API con Swagger UI y ReDoc.
Seguridad de Tipos: Aprovechando las sugerencias de tipo de Python, FastAPI asegura un código robusto y libre de errores.

La Importancia de la Autenticación

Al construir APIs, asegurarlas con mecanismos de autenticación es esencial para proteger datos sensibles y asegurar que solo los usuarios autorizados puedan acceder a ciertos endpoints. La autenticación ayuda a verificar la identidad de los usuarios o sistemas que interactúan con tu API, proporcionando una capa de seguridad y confianza.

Tipos de Autenticación

FastAPI soporta múltiples tipos de autenticación, incluyendo:

Autenticación Básica: Un método sencillo que usa un nombre de usuario y contraseña.
OAuth2: Un método más seguro y flexible, a menudo usado para autenticación de terceros.
JWT (JSON Web Tokens): Una forma compacta y autocontenida de transmitir información de forma segura.

Configurando la Autenticación en FastAPI

Ahora, vamos al corazón del asunto: configurar la autenticación en FastAPI. Cubriremos una implementación básica de OAuth2 con Contraseña (y hashing), una de las formas más comunes y seguras de manejar la autenticación.

Paso 1: Instala FastAPI y Dependencias

Primero, asegúrate de tener FastAPI y las dependencias necesarias instaladas. Puedes hacer esto usando pip:

pip install fastapi[all] uvicorn

El [all] instala todas las dependencias necesarias para la autenticación, incluyendo pydantic y python-jose para JWT.

Paso 2: Crea una Aplicación FastAPI Básica

Empecemos con una aplicación FastAPI simple. Crea un archivo llamado main.py:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

Puedes ejecutar esta aplicación usando Uvicorn:

uvicorn main:app --reload

Paso 3: Implementando OAuth2 con Contraseña

OAuth2 es un framework de autorización ampliamente usado que proporciona flujos de autorización específicos para diferentes tipos de aplicaciones. Usaremos OAuth2 con Contraseña (y hashing) para gestionar la autenticación.

Creando Modelos de Usuario

Primero, define tus modelos de usuario. Crea un archivo llamado models.py:

from pydantic import BaseModel

class User(BaseModel):
    username: str
    email: str
    full_name: str
    disabled: bool = False

class UserInDB(User):
    hashed_password: str

Utilidad de Hashing de Contraseñas

A continuación, necesitarás una utilidad para hacer hash y verificar contraseñas. Crea un archivo llamado security.py:

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def verify_password(plain_password, hashed_password):
    return pwd_context.verify(plain_password, hashed_password)

def get_password_hash(password):
    return pwd_context.hash(password)

Flujo de Contraseña OAuth2

Ahora, configura el Flujo de Contraseña OAuth2. Actualiza tu main.py para incluir lo siguiente:

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from jose import JWTError, jwt
from pydantic import BaseModel
from typing import Optional
import time

# Secret key to encode JWT
SECRET_KEY = "your_secret_key"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

# User database simulation
fake_users_db = {
    "johndoe": {
        "username": "johndoe",
        "full_name": "John Doe",
        "email": "johndoe@example.com",
        "hashed_password": "$2b$12$...",
        "disabled": False,
    }
}

class Token(BaseModel):
    access_token: str
    token_type: str

class TokenData(BaseModel):
    username: Optional[str] = None

def authenticate_user(fake_db, username: str, password: str):
    user = fake_db.get(username)
    if not user:
        return False
    if not verify_password(password, user["hashed_password"]):
        return False
    return user

def create_access_token(data: dict, expires_delta: Optional[int] = None):
    to_encode = data.copy()
    if expires_delta:
        expire = time.time() + expires_delta
    else:
        expire = time.time() + ACCESS_TOKEN_EXPIRE_MINUTES * 60
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

@app.post("/token", response_model=Token)
async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
    user = authenticate_user(fake_users_db, form_data.username, form_data.password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Nombre de usuario o contraseña incorrectos",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token = create_access_token(data={"sub": user["username"]})
    return {"access_token": access_token, "token_type": "bearer"}

@app.get("/users/me", response_model=User)
async def read_users_me(token: str = Depends(oauth2_scheme)):
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="No se pudieron validar las credenciales",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
        token_data = TokenData(username=username)
    except JWTError:
        raise credentials_exception
    user = fake_users_db.get(username, None)
    if user is None:
        raise credentials_exception
    return user

Este código configura un flujo de contraseña OAuth2 simple. Los usuarios pueden obtener un token proporcionando su nombre de usuario y contraseña al endpoint /token, y pueden usar este token para autenticarse en endpoints protegidos como /users/me.

Paso 4: Probando tu Autenticación

Para probar tu autenticación, puedes usar una herramienta de prueba de API como Postman o Apidog. Aquí te mostramos cómo puedes hacerlo con Apidog:

Crear una Nueva solicitud: Abre Apidog y crea una nueva solicitud.

Mejorando tu Autenticación en FastAPI con Apidog

Mientras que FastAPI facilita la configuración de la autenticación, herramientas como Apidog pueden agilizar aún más el proceso proporcionando una plataforma para diseñar, documentar y probar tus APIs. Apidog ofrece una interfaz fácil de usar para gestionar tus endpoints de API, simular respuestas y colaborar con tu equipo.

Beneficios de Usar Apidog

Gestión Integral de APIs: Diseña, prueba y documenta tus APIs en un solo lugar.
Colaboración: Trabaja con tu equipo en tiempo real, comparte endpoints y revisa cambios.
Respuestas Simuladas: Simula respuestas de API para probar sin golpear los endpoints reales.

Conclusión

FastAPI simplifica el proceso de construir y asegurar APIs, haciéndolo una opción superior para desarrolladores que buscan rendimiento y facilidad de uso. Implementando la autenticación con FastAPI, aseguras que tus APIs son seguras y solo accesibles para usuarios autorizados. Adicionalmente, aprovechar herramientas como Apidog puede mejorar tu experiencia de desarrollo de API proporcionando capacidades robustas de gestión y prueba.

Ahora que sabes cómo implementar la autenticación en FastAPI, puedes asegurar con confianza tus APIs y proteger tus datos. ¡Feliz codificación!

button