0Pricing
Python Academy · Lekcja

Wstrzykiwanie zależności i uwierzytelnianie

Proszę używać systemu DI FastAPI do współdzielonej logiki oraz uwierzytelniania opartego na JWT.

Wstrzykiwanie zależności i uwierzytelnianie to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Python Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Python Academy zawiera 4 lekcji w sumie.

Czym jest wstrzykiwanie zależności?

Depends() w FastAPI pozwala zadeklarować współdzieloną logikę (sesje bazy danych, sprawdzanie uwierzytelnienia, konfigurację), która jest automatycznie wstrzykiwana do handlerów tras.

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

Funkcje zależności

Zależnością może być dowolny obiekt wywoływalny. Może to być funkcja, klasa lub inna funkcja korzystająca z zależności.

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

Zależności oparte na klasach

Klasy można używać jako zależności do grupowania powiązanych ustawień. Klasa jest wywoływana z argumentami __init__ wstrzykniętymi automatycznie.

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

OAuth2PasswordBearer służy do odczytywania tokenu Bearer z nagłówka 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

Tokeny JWT

Tokeny JWT można tworzyć i weryfikować za pomocą python-jose (lub pyjwt). Podczas logowania należy zwrócić token, a następnie weryfikować go na każdej chronionej trasie.

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

Zależność bieżącego użytkownika

Należy utworzyć zależność get_current_user, która weryfikuje token JWT i zwraca uwierzytelnionego użytkownika.

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

Haszowanie haseł

Nie należy nigdy przechowywać haseł w postaci jawnej. Do haszowania za pomocą bcrypt służy passlib.

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 tokenu

Należy zaimplementować POST /token, który przyjmuje dane uwierzytelniające w formularzu, weryfikuje hasło i zwraca token 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"}

Uwierzytelnianie za pomocą klucza API

W prostszych przypadkach można weryfikować klucz API przekazany w nagłówku lub parametrze zapytania.

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

Kontrola dostępu oparta na rolach

Uprawnienia można nałożyć na uwierzytelnianie, dodając sprawdzanie ról do zależności.

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

Buforowanie zależności

Domyślnie zależność jest wywoływana raz na żądanie, a jej wynik jest współdzielony przez wszystkie trasy, które korzystają z niej w ramach tego żądania.

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

Szybkie sprawdzenie

Co robi Depends() w FastAPI?

Podsumowanie

Do wstrzykiwania współdzielonej logiki należy używać Depends(func). Uwierzytelnianie należy zbudować za pomocą OAuth2PasswordBearer, tokenów JWT oraz zależności get_current_user. Hasła należy haszować za pomocą passlib/bcrypt. Sprawdzanie ról należy dodać jako kolejne zależności.

Często zadawane pytania

Czy lekcja „Wstrzykiwanie zależności i uwierzytelnianie” jest bezpłatna?

Tak — pełny tekst „Wstrzykiwanie zależności i uwierzytelnianie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Python Academy, przejdź na CoddyKit PRO. Kurs Python Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Wstrzykiwanie zależności i uwierzytelnianie”?

Proszę używać systemu DI FastAPI do współdzielonej logiki oraz uwierzytelniania opartego na JWT. Ćwiczysz Python Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Python Academy?

Nie wymagamy żadnego doświadczenia. Python Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Wstrzykiwanie zależności i uwierzytelnianie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Python Academy?

Tak. Każda lekcja Python Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Konfiguracja projektu FastAPI i pierwszy endpoint
  2. Parametry ścieżki, parametry zapytania i treści żądań
  3. Wstrzykiwanie zależności i uwierzytelnianie
  4. Asynchroniczne endpointy i integracja z bazą danych
← Powrót do Python Academy