0Pricing
Python Academy · Lección

Inyección de dependencias y autenticación

Utilice el sistema de DI de FastAPI para lógica compartida y autenticación basada en JWT.

Inyección de dependencias y autenticación es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

¿Qué es la inyección de dependencias?

Depends() de FastAPI permite declarar lógica compartida (sesiones de base de datos, comprobaciones de autenticación y configuración) que se inyecta automáticamente en los controladores de las rutas.

from fastapi import FastAPI, Depends
app = FastAPI()

def get_db():
    db = connect_db()
    try: yield db
    finally: db.close()

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query_all("users")

Funciones de dependencia

Una dependencia es cualquier objeto invocable. Puede ser una función, una clase u otra función que utilice dependencias.

from fastapi import Depends, FastAPI
app = FastAPI()

def common_params(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(common_params)):
    return params

@app.get("/users")
def list_users(params: dict = Depends(common_params)):
    return params

Dependencias basadas en clases

Use una clase como dependencia para agrupar configuraciones relacionadas. La clase se invoca con sus argumentos de __init__ inyectados.

from fastapi import Depends, FastAPI, Query
app = FastAPI()

class Pagination:
    def __init__(self, page: int = Query(1,ge=1), size: int = Query(10,ge=1,le=100)):
        self.page = page
        self.size = size
        self.offset = (page - 1) * size

@app.get("/items")
def list_items(pag: Pagination = Depends()):
    return {"offset": pag.offset, "size": pag.size}

OAuth2 Password Bearer

Use OAuth2PasswordBearer para leer un token Bearer del encabezado Authorization.

from fastapi import FastAPI, Depends
from fastapi.security import OAuth2PasswordBearer
app = FastAPI()

oauth2 = OAuth2PasswordBearer(tokenUrl="/token")

@app.get("/me")
def me(token: str = Depends(oauth2)):
    return {"token": token}   # validate token here

Tokens JWT

Cree y verifique tokens JWT con python-jose (o pyjwt). Devuelva un token al iniciar sesión y verifíquelo en todas las rutas protegidas.

# pip install python-jose passlib
from jose import jwt, JWTError

SECRET_KEY = "change-me"
ALGORITHM = "HS256"

def create_token(data: dict) -> str:
    return jwt.encode(data, SECRET_KEY, algorithm=ALGORITHM)

def verify_token(token: str) -> dict:
    return jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])

Dependencia del usuario actual

Construya una dependencia get_current_user que verifique el JWT y devuelva el usuario autenticado.

from fastapi import Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer
from jose import jwt, JWTError

oauth2 = OAuth2PasswordBearer(tokenUrl="/token")

def get_current_user(token: str = Depends(oauth2)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        return payload["sub"]
    except JWTError:
        raise HTTPException(status_code=401, detail="Invalid token")

# @app.get("/me")
# def me(user=Depends(get_current_user)): return user

Hashing de contraseñas

No almacene nunca contraseñas en texto plano. Use passlib para aplicar un hash con bcrypt.

from passlib.context import CryptContext

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

def hash_pw(plain: str) -> str:
    return pwd_ctx.hash(plain)

def verify_pw(plain: str, hashed: str) -> bool:
    return pwd_ctx.verify(plain, hashed)

Endpoint de tokens

Implemente POST /token para aceptar credenciales de formulario, verificar la contraseña y devolver un JWT.

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import OAuth2PasswordRequestForm
app = FastAPI()

@app.post("/token")
def login(form: OAuth2PasswordRequestForm = Depends()):
    user = get_user_by_username(form.username)
    if not user or not verify_pw(form.password, user.hashed_pw):
        raise HTTPException(status_code=401, detail="Bad credentials")
    token = create_token({"sub": form.username})
    return {"access_token": token, "token_type": "bearer"}

Autenticación mediante clave de API

En casos más sencillos, valide una clave de API procedente de un encabezado o de un parámetro de consulta.

from fastapi import Depends, HTTPException, Security
from fastapi.security import APIKeyHeader

API_KEY_HEADER = APIKeyHeader(name="X-API-Key")

def require_api_key(key: str = Security(API_KEY_HEADER)):
    if key != "secret-key":
        raise HTTPException(status_code=403, detail="Forbidden")
    return key

Control de acceso basado en roles

Añada permisos sobre la autenticación incorporando comprobaciones de roles a las dependencias.

from fastapi import Depends, HTTPException

def require_admin(user=Depends(get_current_user)):
    if user.get("role") != "admin":
        raise HTTPException(status_code=403, detail="Admins only")
    return user

# @app.delete("/users/{uid}")
# def delete_user(uid: int, admin=Depends(require_admin)):

Almacenamiento en caché de dependencias

De forma predeterminada, una dependencia se llama una vez por solicitud y su resultado se comparte entre todas las rutas que la utilizan durante esa solicitud.

# The same db session object is shared:
@app.get("/summary")
def summary(
    db = Depends(get_db),      # db resolved once
    stats = Depends(get_stats) # get_stats also uses get_db — same db instance
): ...

Comprobación rápida

¿Qué hace Depends() en FastAPI?

Repaso

Use Depends(func) para inyectar lógica compartida. Implemente la autenticación con OAuth2PasswordBearer, tokens JWT y una dependencia get_current_user. Hashee las contraseñas con passlib/bcrypt. Añada comprobaciones de roles como dependencias adicionales.

Preguntas frecuentes

¿La lección «Inyección de dependencias y autenticación» es gratis?

Sí — el texto completo de «Inyección de dependencias y autenticación» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Inyección de dependencias y autenticación»?

Utilice el sistema de DI de FastAPI para lógica compartida y autenticación basada en JWT. Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Inyección de dependencias y autenticación»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Configuración de un proyecto FastAPI y primer endpoint
  2. Parámetros de ruta, parámetros de consulta y cuerpos de solicitud
  3. Inyección de dependencias y autenticación
  4. Endpoints asíncronos e integración con bases de datos
← Volver a Python Academy