0Pricing
Python Academy · Lezione

Dependency injection e autenticazione

Utilizzi il sistema DI di FastAPI per la logica condivisa e l'autenticazione basata su JWT.

Dependency injection e autenticazione è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Che cos'è la dependency injection?

Depends() di FastAPI consente di dichiarare logica condivisa (sessioni DB, controlli di autenticazione, configurazione) che viene inserita automaticamente nei gestori delle route.

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")

Funzioni di dependency

Una dependency è qualsiasi oggetto chiamabile. Può essere una funzione, una classe o un'altra funzione che utilizza una dependency.

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

Dependency basate su classi

Utilizzi una classe come dependency per raggruppare impostazioni correlate. La classe viene chiamata con gli argomenti del suo __init__ inseriti automaticamente.

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

Utilizzi OAuth2PasswordBearer per leggere un token Bearer dall'header 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

Token JWT

Crei e verifichi i token JWT con python-jose (oppure pyjwt). Restituisca un token al login e lo verifichi in ogni route protetta.

# 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])

Dependency per l'utente corrente

Crei una dependency get_current_user che verifichi il JWT e restituisca l'utente autenticato.

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 delle password

Non memorizzi mai le password in chiaro. Utilizzi passlib per applicare l'hashing 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 dei token

Implementi POST /token per accettare credenziali nel form, verificare la password e restituire 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"}

Autenticazione con API key

Per i casi più semplici, convalidi una API key proveniente da un header o da un parametro di query.

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

Controllo degli accessi basato sui ruoli

Costruisca i permessi sopra l'autenticazione aggiungendo controlli dei ruoli alle dependency.

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)):

Caching delle dependency

Per impostazione predefinita, una dependency viene chiamata una volta per richiesta e il suo risultato viene condiviso tra tutte le route che la utilizzano nella richiesta.

# 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
): ...

Verifica rapida

Che cosa fa Depends() in FastAPI?

Riepilogo

Utilizzi Depends(func) per iniettare la logica condivisa. Implementi l'autenticazione con OAuth2PasswordBearer, token JWT e una dipendenza get_current_user. Esegua l'hashing delle password con passlib/bcrypt. Aggiunga i controlli dei ruoli come ulteriori dipendenze.

Domande Frequenti

La lezione «Dependency injection e autenticazione» è gratuita?

Sì — il testo completo di «Dependency injection e autenticazione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «Dependency injection e autenticazione»?

Utilizzi il sistema DI di FastAPI per la logica condivisa e l'autenticazione basata su JWT. Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Dependency injection e autenticazione»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Configurazione di un progetto FastAPI e primo endpoint
  2. Parametri del percorso, parametri query e body delle richieste
  3. Dependency injection e autenticazione
  4. Endpoint asincroni e integrazione con il database
← Torna a Python Academy