FastAPIs avhengighetssystem: Avansert 'Dependency Injection'

FastAPIs system for 'dependency injection' (DI) er en hjørnestein i designet, og fremmer modularitet, testbarhet og gjenbrukbarhet. Mens grunnleggende bruk er rett frem, låser mestring av avanserte DI-teknikker opp betydelig kraft og fleksibilitet. Denne artikkelen dykker ned i avansert 'dependency injection' i FastAPI, og dekker egendefinerte avhengigheter, 'scopes', teststrategier og beste praksis.

Forstå det grunnleggende

Før vi dykker ned i avanserte temaer, la oss raskt oppsummere det grunnleggende om FastAPIs 'dependency injection':

• Avhengigheter som funksjoner: Avhengigheter deklareres som vanlige Python-funksjoner.
• Automatisk injeksjon: FastAPI injiserer automatisk disse avhengighetene i 'path operations' basert på typetips.
• Typetips som kontrakter: Typetips definerer de forventede input-typene for avhengigheter og 'path operation'-funksjoner.
• Hierarkiske avhengigheter: Avhengigheter kan avhenge av andre avhengigheter, og skaper dermed et avhengighetstre.

Her er et enkelt eksempel:

            
from fastapi import FastAPI, Depends

app = FastAPI()

def get_db():
    db = {"items": []}
    try:
        yield db
    finally:
        # Lukk tilkoblingen om nødvendig
        pass

@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
    return db["items"]

            

              
                Copy
              
            
          

I dette eksempelet er get_db en avhengighet som gir en databasetilkobling. FastAPI kaller automatisk get_db og injiserer resultatet i read_items-funksjonen.

Avanserte avhengighetsteknikker

1. Bruk av klasser som avhengigheter

Selv om funksjoner er vanlig brukt, kan klasser også fungere som avhengigheter, noe som tillater mer kompleks tilstandshåndtering og metoder. Dette er spesielt nyttig når man håndterer databasetilkoblinger, autentiseringstjenester eller andre ressurser som krever initialisering og opprydding.

            
from fastapi import FastAPI, Depends

app = FastAPI()

class Database:
    def __init__(self):
        self.connection = self.create_connection()

    def create_connection(self):
        # Simulerer en databasetilkobling
        print("Oppretter databasetilkobling...")
        return {"items": []}

    def close(self):
        # Simulerer lukking av en databasetilkobling
        print("Lukker databasetilkobling...")

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

@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
    return db["items"]

            

              
                Copy
              
            
          

I dette eksempelet innkapsler Database-klassen logikken for databasetilkoblingen. get_db-avhengigheten oppretter en instans av Database-klassen og 'yield'-er tilkoblingen. finally-blokken sikrer at tilkoblingen lukkes korrekt etter at forespørselen er behandlet.

2. Overstyring av avhengigheter

FastAPI lar deg overstyre avhengigheter, noe som er avgjørende for testing og utvikling. Du kan erstatte en ekte avhengighet med en 'mock' eller 'stub' for å isolere koden din og sikre konsistente resultater.

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Opprinnelig avhengighet
def get_settings():
    # Simulerer lasting av innstillinger fra en fil eller miljø
    return {"api_key": "real_api_key"}

@app.get("/items/")
async def read_items(settings: dict = Depends(get_settings)):
    return {"api_key": settings["api_key"]}

# Overstyring for testing
def get_settings_override():
    return {"api_key": "test_api_key"}

app.dependency_overrides[get_settings] = get_settings_override

# For å gå tilbake til originalen:
# del app.dependency_overrides[get_settings]

            

              
                Copy
              
            
          

I dette eksempelet blir get_settings-avhengigheten overstyrt med get_settings_override. Dette lar deg bruke en annen API-nøkkel for testformål.

3. Bruk av `contextvars` for forespørsels-spesifikke data

contextvars er en Python-modul som tilbyr kontekstlokale variabler. Dette er nyttig for å lagre forespørselsspesifikke data, som brukerautentiseringsinformasjon, forespørsels-ID-er eller sporingsdata. Ved å bruke contextvars med FastAPIs 'dependency injection' kan du få tilgang til disse dataene i hele applikasjonen.

            
import contextvars
from fastapi import FastAPI, Depends, Request

app = FastAPI()

# Opprett en kontekstvariabel for forespørsels-ID
request_id_var = contextvars.ContextVar("request_id")

# Middleware for å sette forespørsels-ID
@app.middleware("http")
async def add_request_id(request: Request, call_next):
    request_id = str(uuid.uuid4())
    request_id_var.set(request_id)
    response = await call_next(request)
    response.headers["X-Request-ID"] = request_id
    return response

# Avhengighet for å få tilgang til forespørsels-ID
def get_request_id():
    return request_id_var.get()

@app.get("/items/")
async def read_items(request_id: str = Depends(get_request_id)):
    return {"request_id": request_id}

            

              
                Copy
              
            
          

I dette eksempelet setter en middleware en unik forespørsels-ID for hver innkommende forespørsel. get_request_id-avhengigheten henter forespørsels-ID-en fra contextvars-konteksten. Dette lar deg spore forespørsler på tvers av applikasjonen din.

4. Asynkrone avhengigheter

FastAPI støtter sømløst asynkrone avhengigheter. Dette er essensielt for ikke-blokkerende I/O-operasjoner, som databasekall eller eksterne API-kall. Definer enkelt avhengighetsfunksjonen din som en async def-funksjon.

            
from fastapi import FastAPI, Depends
import asyncio

app = FastAPI()

async def get_data():
    # Simulerer en asynkron operasjon
    await asyncio.sleep(1)
    return {"message": "Hello from async dependency!"}

@app.get("/items/")
async def read_items(data: dict = Depends(get_data)):
    return data

            

              
                Copy
              
            
          

I dette eksempelet er get_data-avhengigheten en asynkron funksjon som simulerer en forsinkelse. FastAPI venter automatisk på ('await') resultatet av den asynkrone avhengigheten før den injiseres i read_items-funksjonen.

5. Bruk av generatorer for ressursstyring (databasetilkoblinger, filhåndtak)

Bruk av generatorer (med yield) gir automatisk ressursstyring, og garanterer at ressurser blir lukket/frigjort korrekt via finally-blokken selv om det oppstår feil.

            
from fastapi import FastAPI, Depends

app = FastAPI()


def get_file_handle():
    try:
        file_handle = open("my_file.txt", "r")
        yield file_handle
    finally:
        file_handle.close()

@app.get("/file_content/")
async def read_file_content(file_handle = Depends(get_file_handle)):
    content = file_handle.read()
    return {"content": content}

            

              
                Copy
              
            
          

Avhengigheters 'Scopes' og livssykluser

Å forstå 'scopes' for avhengigheter er avgjørende for å håndtere livssyklusen til avhengigheter og sikre at ressurser blir korrekt allokert og frigjort. FastAPI tilbyr ikke direkte eksplisitte 'scope'-annotasjoner som noen andre DI-rammeverk (f.eks. Springs `@RequestScope`, `@ApplicationScope`), men kombinasjonen av hvordan du definerer avhengigheter og hvordan du håndterer tilstand oppnår lignende resultater.

Forespørsels-'scope' (Request Scope)

Dette er det vanligste 'scopet'. Hver forespørsel mottar en ny instans av avhengigheten. Dette oppnås vanligvis ved å opprette et nytt objekt inne i en avhengighetsfunksjon og 'yield'-e det, som vist i databaseeksemplet tidligere. Bruk av contextvars bidrar også til å oppnå forespørsels-'scope'.

Applikasjons-'scope' (Singleton)

En enkelt instans av avhengigheten opprettes og deles på tvers av alle forespørsler gjennom hele applikasjonens livssyklus. Dette gjøres ofte ved hjelp av globale variabler eller attributter på klassenivå.

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Singleton-instans
GLOBAL_SETTING = {"api_key": "global_api_key"}

def get_global_setting():
    return GLOBAL_SETTING

@app.get("/items/")
async def read_items(setting: dict = Depends(get_global_setting)):
    return setting

            

              
                Copy
              
            
          

Vær forsiktig når du bruker applikasjons-spesifikke avhengigheter med muterbar tilstand, da endringer gjort av én forespørsel kan påvirke andre forespørsler. Synkroniseringsmekanismer (låser, etc.) kan være nødvendig hvis applikasjonen din har samtidige forespørsler.

Sesjons-'scope' (Brukspesifikke data)

Knytt avhengigheter til bruker-sesjoner. Dette krever en mekanisme for sesjonshåndtering (f.eks. ved hjelp av informasjonskapsler eller JWT-er) og innebærer vanligvis lagring av avhengigheter i sesjonsdataene.

            
from fastapi import FastAPI, Depends, Cookie
from typing import Optional
import uuid

app = FastAPI()

# I en ekte applikasjon, lagre sesjoner i en database eller cache
sessions = {}

async def get_user_id(session_id: Optional[str] = Cookie(None)) -> str:
    if session_id is None or session_id not in sessions:
        session_id = str(uuid.uuid4())
        sessions[session_id] = {"user_id": str(uuid.uuid4())} # Tildel en tilfeldig bruker-ID
        
    return sessions[session_id]["user_id"]

@app.get("/profile/")
async def read_profile(user_id: str = Depends(get_user_id)):
    return {"user_id": user_id}

            

              
                Copy
              
            
          

Testing av avhengigheter

En av de fremste fordelene med 'dependency injection' er forbedret testbarhet. Ved å frikoble komponenter kan du enkelt erstatte avhengigheter med 'mocks' eller 'stubs' under testing.

1. Overstyring av avhengigheter i tester

Som vist tidligere, er FastAPIs dependency_overrides-mekanisme ideell for testing. Lag 'mock'-avhengigheter som returnerer forutsigbare resultater, og bruk dem til å isolere koden du tester.

            
from fastapi.testclient import TestClient
from fastapi import FastAPI, Depends

app = FastAPI()

# Opprinnelig avhengighet
def get_external_data():
    # Simulerer henting av data fra et eksternt API
    return {"data": "Real external data"}

@app.get("/data/")
async def read_data(data: dict = Depends(get_external_data)):
    return data

# Test
from unittest.mock import MagicMock

def get_external_data_mock():
    return {"data": "Mocked external data"}


def test_read_data():
    app.dependency_overrides[get_external_data] = get_external_data_mock
    client = TestClient(app)
    response = client.get("/data/")
    assert response.status_code == 200
    assert response.json() == {"data": "Mocked external data"}

    # Rydd opp i overstyringene
    app.dependency_overrides.clear()


            

              
                Copy
              
            
          

2. Bruk av 'mocking'-biblioteker

Biblioteker som unittest.mock gir kraftige verktøy for å lage 'mock'-objekter og kontrollere deres oppførsel. Du kan bruke 'mocks' til å simulere komplekse avhengigheter og verifisere at koden din samhandler korrekt med dem.

            
import unittest
from unittest.mock import MagicMock

# (Definer FastAPI-appen og get_external_data som over)

class TestReadData(unittest.TestCase):
    def test_read_data_with_mock(self):
        # Opprett en mock for get_external_data-avhengigheten
        mock_get_external_data = MagicMock(return_value={"data": "Mocked data from unittest"})

        # Overstyr avhengigheten med mock-en
        app.dependency_overrides[get_external_data] = mock_get_external_data

        client = TestClient(app)
        response = client.get("/data/")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {"data": "Mocked data from unittest"})

        # Bekreft at mock-en ble kalt
        mock_get_external_data.assert_called_once()

        # Rydd opp i overstyringene
        app.dependency_overrides.clear()

            

              
                Copy
              
            
          

3. 'Dependency Injection' for enhetstesting (Utenfor FastAPI-kontekst)

Selv når du enhetstester funksjoner *utenfor* API-endepunktenes 'handlers', gjelder prinsippene for 'dependency injection'. I stedet for å stole på FastAPIs Depends, injiser avhengighetene manuelt i funksjonen som testes.

            
# Eksempelfunksjon for testing
def process_data(data_source):
    data = data_source.fetch_data()
    # ... behandle dataene ...
    return processed_data

class MockDataSource:
    def fetch_data(self):
        return {"example": "data"}

# Enhetstest
def test_process_data():
    mock_data_source = MockDataSource()
    result = process_data(mock_data_source)
    # Påstander om resultatet

            

              
                Copy
              
            
          

Sikkerhetshensyn med 'Dependency Injection'

'Dependency injection', selv om det er nyttig, introduserer potensielle sikkerhetsbekymringer hvis det ikke implementeres nøye.

1. 'Dependency Confusion'

Sørg for at du henter avhengigheter fra pålitelige kilder. Verifiser pakkeintegritet og bruk pakkebehandlere med sårbarhetsskanning. Dette er et generelt sikkerhetsprinsipp for programvareforsyningskjeden, men det forsterkes av DI siden du kan injisere komponenter fra ulike kilder.

2. Injeksjon av ondsinnede avhengigheter

Vær oppmerksom på avhengigheter som aksepterer ekstern input uten skikkelig validering. En angriper kan potensielt injisere ondsinnet kode eller data gjennom en kompromittert avhengighet. Rens all brukerinput og implementer robuste valideringsmekanismer.

3. Informasjonslekkasje gjennom avhengigheter

Sørg for at avhengigheter ikke utilsiktet eksponerer sensitiv informasjon. Gjennomgå koden og konfigurasjonen av avhengighetene dine for å identifisere potensielle sårbarheter for informasjonslekkasje.

4. Hardkodede hemmeligheter

Unngå å hardkode hemmeligheter (API-nøkler, databasepassord, etc.) direkte i avhengighetskoden din. Bruk miljøvariabler eller sikre konfigurasjonshåndteringsverktøy for å lagre og administrere hemmeligheter.

            
import os
from fastapi import FastAPI, Depends

app = FastAPI()


def get_api_key():
    api_key = os.environ.get("API_KEY")
    if not api_key:
        raise ValueError("Miljøvariabelen API_KEY er ikke satt.")
    return api_key

@app.get("/secure_endpoint/")
async def secure_endpoint(api_key: str = Depends(get_api_key)):
    # Bruk api_key for autentisering/autorisasjon
    return {"message": "Access granted"}

            

              
                Copy
              
            
          

Ytelsesoptimalisering med 'Dependency Injection'

'Dependency injection' kan påvirke ytelsen hvis det ikke brukes fornuftig. Her er noen optimaliseringsstrategier:

1. Minimer kostnaden ved å opprette avhengigheter

Unngå å opprette kostbare avhengigheter for hver forespørsel hvis mulig. Hvis en avhengighet er tilstandsløs eller kan deles på tvers av forespørsler, bør du vurdere å bruke et singleton-'scope' eller cache avhengighetsinstansen.

2. 'Lazy Initialization' (Utsatt initialisering)

Initialiser avhengigheter kun når de trengs. Dette kan redusere oppstartstid og minneforbruk, spesielt for applikasjoner med mange avhengigheter.

3. Caching av avhengighetsresultater

Cache resultatene av kostbare beregninger i avhengigheter hvis resultatene sannsynligvis vil bli gjenbrukt. Bruk cache-mekanismer (f.eks. Redis, Memcached) for å lagre og hente avhengighetsresultater.

4. Optimaliser avhengighetsgrafen

Analyser avhengighetsgrafen din for å identifisere potensielle flaskehalser. Forenkle avhengighetsstrukturen og reduser antall avhengigheter hvis mulig.

5. Asynkrone avhengigheter for I/O-bundne operasjoner

Bruk asynkrone avhengigheter når du utfører blokkerende I/O-operasjoner, som databasekall eller eksterne API-kall. Dette forhindrer blokkering av hovedtråden og forbedrer den generelle responsen i applikasjonen.

Beste praksis for 'Dependency Injection' i FastAPI

• Hold avhengigheter enkle: Sikt mot små, fokuserte avhengigheter som utfører én enkelt oppgave. Dette forbedrer lesbarhet, testbarhet og vedlikeholdbarhet.
• Bruk typetips: Utnytt typetips for å tydelig definere forventede input- og output-typer for avhengigheter. Dette forbedrer kodens klarhet og lar FastAPI utføre statisk typesjekking.
• Dokumenter avhengigheter: Dokumenter formålet med og bruken av hver avhengighet. Dette hjelper andre utviklere å forstå hvordan de skal bruke og vedlikeholde koden din.
• Test avhengigheter grundig: Skriv enhetstester for avhengighetene dine for å sikre at de oppfører seg som forventet. Dette bidrar til å forhindre feil og forbedre den generelle påliteligheten til applikasjonen din.
• Bruk konsekvente navnekonvensjoner: Bruk konsekvente navnekonvensjoner for avhengighetene dine for å forbedre kodens lesbarhet.
• Unngå sirkulære avhengigheter: Sirkulære avhengigheter kan føre til kompleks og vanskelig-å-debugge kode. Refaktorer koden din for å eliminere sirkulære avhengigheter.
• Vurder 'Dependency Injection'-containere (Valgfritt): Mens FastAPIs innebygde 'dependency injection' er tilstrekkelig for de fleste tilfeller, bør du vurdere å bruke en dedikert 'dependency injection'-container (f.eks. inject, autowire) for mer komplekse applikasjoner.

Konklusjon

FastAPIs system for 'dependency injection' er et kraftig verktøy som fremmer modularitet, testbarhet og gjenbrukbarhet. Ved å mestre avanserte teknikker, som å bruke klasser som avhengigheter, overstyre avhengigheter og bruke contextvars, kan du bygge robuste og skalerbare API-er. Å forstå avhengigheters 'scopes' og livssykluser er avgjørende for å håndtere ressurser effektivt. Prioriter alltid å teste avhengighetene dine grundig for å sikre påliteligheten og sikkerheten til applikasjonene dine. Ved å følge beste praksis og vurdere potensielle sikkerhets- og ytelsesimplikasjoner, kan du utnytte det fulle potensialet i FastAPIs system for 'dependency injection'.