FastAPI Dependency Injection: Avansert DI Container Arkitektur

FastAPI, med sitt intuitive design og kraftige funksjoner, har blitt en favoritt for å bygge moderne web API-er i Python. En av dens kjerne styrker ligger i dens sømløse integrasjon med dependency injection (DI), som gjør det mulig for utviklere å lage løst koblede, testbare og vedlikeholdbare applikasjoner. Mens FastAPIs innebygde DI-system er utmerket for enkle brukstilfeller, drar mer komplekse prosjekter ofte nytte av en mer strukturert og avansert DI-container arkitektur. Denne artikkelen utforsker ulike strategier for å bygge en slik arkitektur, og gir praktiske eksempler og innsikt for design av robuste og skalerbare applikasjoner.

Forstå Dependency Injection (DI) og Inversion of Control (IoC)

Før vi dykker ned i avanserte DI-container arkitekturer, la oss klargjøre de grunnleggende konseptene:

• Dependency Injection (DI): Et designmønster der avhengigheter leveres til en komponent fra eksterne kilder i stedet for å bli opprettet internt. Dette fremmer løs kobling, noe som gjør komponenter lettere å teste og gjenbruke.
• Inversion of Control (IoC): Et bredere prinsipp der kontrollen over opprettelse og administrasjon av objekter er reversert – delegert til et rammeverk eller en container. DI er en spesifikk type IoC.

FastAPI støtter iboende DI gjennom sitt avhengighetssystem. Du definerer avhengigheter som kallbare objekter (funksjoner, klasser, etc.), og FastAPI løser og injiserer dem automatisk inn i dine endepunktfunksjoner eller andre avhengigheter.

Eksempel (Grunnleggende FastAPI DI):

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Avhengighet
def get_db():
    db = {"items": []}  # Simuler en databasekobling
    try:
        yield db
    finally:
        # Lukk databasekoblingen (om nødvendig)
        pass


# Endepunkt med dependency injection
@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 leverer en databasekobling. FastAPI kaller automatisk get_db og injiserer resultatet (db-ordboken) inn i read_items endepunktfunksjonen.

Hvorfor en Avansert DI Container?

FastAPIs innebygde DI fungerer bra for enkle prosjekter, men etter hvert som applikasjoner vokser i kompleksitet, tilbyr en mer sofistikert DI-container flere fordeler:

• Sentralisert Avhengighetsstyring: En dedikert container gir en enkelt sannhetskilde for alle avhengigheter, noe som gjør det lettere å administrere og forstå applikasjonens avhengigheter.
• Konfigurasjons- og Livssyklusstyring: Containeren kan håndtere konfigurasjon og livssyklus for avhengigheter, for eksempel å opprette singletoner, administrere tilkoblinger og frigjøre ressurser.
• Testbarhet: En avansert container forenkler testing ved å la deg enkelt overstyre avhengigheter med mock-objekter eller test-doubles.
• Dekobling: Fremmer større dekobling mellom komponenter, reduserer avhengigheter og forbedrer vedlikeholdbarheten av koden.
• Utvidbarhet: En utvidbar container lar deg legge til egendefinerte funksjoner og integrasjoner etter behov.

Strategier for å Bygge en Avansert DI Container

Det finnes flere tilnærminger for å bygge en avansert DI-container i FastAPI. Her er noen vanlige strategier:

1. Bruke et Dedikert DI-bibliotek (f.eks. `injector`, `dependency_injector`)

Flere kraftige DI-biblioteker er tilgjengelige for Python, som injector og dependency_injector. Disse bibliotekene tilbyr et omfattende sett med funksjoner for å administrere avhengigheter, inkludert:

• Binding: Definere hvordan avhengigheter løses og injiseres.
• Skop: Kontrollere livssyklusen til avhengigheter (f.eks. singleton, transient).
• Konfigurasjon: Administrere konfigurasjonsinnstillinger for avhengigheter.
• AOP (Aspect-Oriented Programming): Avskjære metanrop for tverrgående bekymringer.

Eksempel med `dependency_injector`

dependency_injector er et populært valg for å bygge DI-containere. La oss illustrere bruken med et eksempel:

            
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends

# Definer avhengigheter
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string
        # Initialiser databasekobling
        print(f"Kobler til database: {self.connection_string}")

    def get_items(self):
        # Simuler henting av elementer fra databasen
        return [{"id": 1, "name": "Element 1"}, {"id": 2, "name": "Element 2"}]


class UserRepository:
    def __init__(self, database: Database):
        self.database = database

    def get_all_users(self):
        # Simulering av databaseforespørsel for å hente alle brukere
        return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]

class Settings:
    def __init__(self, database_url):
        self.database_url = database_url

# Definer container
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    settings = providers.Singleton(Settings, database_url = config.database_url)
    database = providers.Singleton(Database, connection_string=config.database_url)
    user_repository = providers.Factory(UserRepository, database=database)

# Opprett FastAPI-app
app = FastAPI()

# Konfigurer container (fra en miljøvariabel)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # aktiverer injeksjon av avhengigheter i FastAPI-endepunkter

# Avhengighet for FastAPI
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Endepunkt som bruker injisert avhengighet
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
    return user_repository.get_all_users()

@app.on_event("startup")
async def startup_event():
    # Container initialisering
    container.init_resources()

            

              
                Copy
              
            
          

Forklaring:

• Vi definerer våre avhengigheter (Database, UserRepository, Settings) som vanlige Python-klasser.
• Vi oppretter en Container-klasse som arver fra containers.DeclarativeContainer. Denne klassen definerer avhengighetene og deres providers (f.eks. providers.Singleton for singletoner, providers.Factory for å opprette nye instanser hver gang).
• Linjen container.wire([__name__]) aktiverer dependency injection inn i FastAPI-endepunkter.
• Funksjonen get_user_repository er en FastAPI-avhengighet som bruker container.user_repository.provided for å hente UserRepository-instansen fra containeren.
• Endepunktfunksjonen read_users injiserer UserRepository-avhengigheten.
• config lar deg eksternalisere avhengighetskonfigurasjonene. Den kan deretter komme fra miljøvariabler, konfigurasjonsfiler osv.
• startup_event brukes til å initialisere ressursene som administreres i containeren.

2. Implementere en Egen DI Container

For mer kontroll over DI-prosessen kan du implementere en egen DI-container. Denne tilnærmingen krever mer innsats, men lar deg skreddersy containeren til dine spesifikke behov.

Grunnleggende Eksempel på Egen DI Container:

            
from typing import Callable, Dict, Type, Any
from fastapi import FastAPI, Depends

class Container:
    def __init__(self):
        self.dependencies: Dict[Type[Any], Callable[..., Any]] = {}
        self.instances: Dict[Type[Any], Any] = {}

    def register(self, dependency_type: Type[Any], provider: Callable[..., Any]):
        self.dependencies[dependency_type] = provider

    def resolve(self, dependency_type: Type[Any]) -> Any:
        if dependency_type in self.instances:
            return self.instances[dependency_type]

        if dependency_type not in self.dependencies:
            raise Exception(f"Avhengighet {dependency_type} er ikke registrert.")

        provider = self.dependencies[dependency_type]
        instance = provider()
        return instance

    def singleton(self, dependency_type: Type[Any], provider: Callable[..., Any]):
        self.register(dependency_type, provider)
        self.instances[dependency_type] = provider()


# Eksempel på Avhengigheter
class PaymentGateway:
    def process_payment(self, amount: float) -> bool:
        print(f"Behandler betaling på ${amount}")
        return True # Simulerer vellykket betaling


class NotificationService:
    def send_notification(self, message: str):
        print(f"Sender varsel: {message}")


# Eksempel på Bruk
container = Container()
container.singleton(PaymentGateway, PaymentGateway)
container.singleton(NotificationService, NotificationService)

app = FastAPI()

# FastAPI Avhengighet
def get_payment_gateway(payment_gateway: PaymentGateway = Depends(lambda: container.resolve(PaymentGateway))):
    return payment_gateway


def get_notification_service(notification_service: NotificationService = Depends(lambda: container.resolve(NotificationService))):
    return notification_service


@app.post("/purchase/")
async def purchase_item(payment_gateway: PaymentGateway = Depends(get_payment_gateway), notification_service: NotificationService = Depends(get_notification_service)):
    if payment_gateway.process_payment(100.0):
        notification_service.send_notification("Kjøp vellykket!")
        return {"message": "Kjøp vellykket"}
    else:
        return {"message": "Kjøp feilet"}

            

              
                Copy
              
            
          

Forklaring:

• Container-klassen administrerer en ordbok med avhengigheter og deres providers.
• register-metoden registrerer en avhengighet med dens provider.
• resolve-metoden løser en avhengighet ved å kalle dens provider.
• singleton-metoden registrerer en avhengighet og oppretter en enkelt instans av den.
• FastAPI-avhengigheter opprettes ved hjelp av en lambdafunksjon for å løse avhengigheter fra containeren.

3. Bruke FastAPIs `Depends` med en Fabrikkfunksjon

I stedet for en fullverdig DI-container, kan du bruke FastAPIs Depends sammen med fabrikkfunksjoner for å oppnå et visst nivå av avhengighetsstyring. Denne tilnærmingen er enklere enn å implementere en egen container, men gir fortsatt noen fordeler sammenlignet med å direkte instansiere avhengigheter i endepunktfunksjoner.

            
from fastapi import FastAPI, Depends
from typing import Callable

# Definer Avhengigheter
class EmailService:
    def __init__(self, smtp_server: str):
        self.smtp_server = smtp_server

    def send_email(self, recipient: str, subject: str, body: str):
        print(f"Sender e-post til {recipient} via {self.smtp_server}: {subject} - {body}")


# Fabrikkfunksjon for EmailService
def create_email_service(smtp_server: str) -> EmailService:
    return EmailService(smtp_server=smtp_server)


# FastAPI
app = FastAPI()

# FastAPI Avhengighet, som utnytter fabrikkfunksjon og Depends
def get_email_service(email_service: EmailService = Depends(lambda: create_email_service(smtp_server="smtp.example.com"))):
    return email_service


@app.post("/send-email/")
async def send_email(recipient: str, subject: str, body: str, email_service: EmailService = Depends(get_email_service)):
    email_service.send_email(recipient=recipient, subject=subject, body=body)
    return {"message": "E-post sendt!"}

            

              
                Copy
              
            
          

Forklaring:

• Vi definerer en fabrikkfunksjon (create_email_service) som oppretter instanser av EmailService-avhengigheten.
• get_email_service-avhengigheten bruker Depends og en lambda for å kalle fabrikkfunksjonen og levere en instans av EmailService.
• Endepunktfunksjonen send_email injiserer EmailService-avhengigheten.

Avanserte Vurderinger

1. Skop og Livssykluser

DI-containere tilbyr ofte funksjoner for å administrere livssyklusen til avhengigheter. Vanlige skop inkluderer:

• Singleton: En enkelt instans av avhengigheten opprettes og gjenbrukes gjennom applikasjonens levetid. Dette er egnet for avhengigheter som er tilstandsløse eller har globalt skop.
• Transient: En ny instans av avhengigheten opprettes hver gang den blir forespurt. Dette er egnet for avhengigheter som er tilstandsdrevne eller trenger å være isolert fra hverandre.
• Request: En enkelt instans av avhengigheten opprettes for hver innkommende forespørsel. Dette er egnet for avhengigheter som trenger å opprettholde tilstand innenfor konteksten av en enkelt forespørsel.

dependency_injector-biblioteket tilbyr innebygd støtte for skop. For egne containere må du implementere skopstyringslogikken selv.

2. Konfigurasjon

Avhengigheter krever ofte konfigurasjonsinnstillinger, som databaseforbindelsesstrenger, API-nøkler og funksjonsflagg. DI-containere kan bidra til å administrere disse innstillingene ved å tilby en sentralisert måte å få tilgang til og injisere konfigurasjonsverdier.

I dependency_injector-eksempelet tillater config-provideren konfigurasjon fra miljøvariabler. For egne containere kan du laste konfigurasjon fra filer eller miljøvariabler og lagre dem i containeren.

3. Testing

En av de primære fordelene med DI er forbedret testbarhet. Med en DI-container kan du enkelt erstatte virkelige avhengigheter med mock-objekter eller test-doubles under testing.

Eksempel (Testing med `dependency_injector`):

            
import pytest
from unittest.mock import MagicMock
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends
from fastapi.testclient import TestClient

# Definer avhengigheter (som før)
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    def get_items(self):
        return [{"id": 1, "name": "Element 1"}, {"id": 2, "name": "Element 2"}]


class UserRepository:
    def __init__(self, database: Database):
        self.database = database

    def get_all_users(self):
        return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]

class Settings:
    def __init__(self, database_url):
        self.database_url = database_url

# Definer container (som før)
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    settings = providers.Singleton(Settings, database_url = config.database_url)
    database = providers.Singleton(Database, connection_string=config.database_url)
    user_repository = providers.Factory(UserRepository, database=database)

# Opprett FastAPI-app (som før)
app = FastAPI()

# Konfigurer container (fra en miljøvariabel)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # aktiverer injeksjon av avhengigheter i FastAPI-endepunkter

# Avhengighet for FastAPI
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Endepunkt som bruker injisert avhengighet (som før)
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
    return user_repository.get_all_users()

@app.on_event("startup")
async def startup_event():
    # Container initialisering
    container.init_resources()

# Test
@pytest.fixture
def test_client():
    # Overstyr databaseavhengigheten med en mock
    database_mock = MagicMock(spec=Database)
    database_mock.get_items.return_value = [{"id": 3, "name": "Test Element"}]

    user_repository_mock = MagicMock(spec = UserRepository)
    user_repository_mock.get_all_users.return_value = [{"id": "test_user", "name": "Test Bruker"}]

    # Overstyr container med mock-avhengigheter
    container.user_repository.override(providers.Factory(lambda: user_repository_mock))

    with TestClient(app) as client:
        yield client
    container.user_repository.reset()


def test_read_users(test_client: TestClient):
    response = test_client.get("/users/")
    assert response.status_code == 200
    assert response.json() ==  [{"id": "test_user", "name": "Test Bruker"}]

            

              
                Copy
              
            
          

Forklaring:

• Vi oppretter et mock-objekt for Database-avhengigheten ved hjelp av MagicMock.
• Vi overstyrer database-provideren i containeren med mock-objektet ved hjelp av container.database.override().
• Testfunksjonen test_read_items bruker nå mock-databasen.
• Etter testutførelse nullstiller den containerens overstyrte avhengighet.

4. Asynkrone Avhengigheter

FastAPI er bygget på asynkron programmering (async/await). Når du jobber med asynkrone avhengigheter (f.eks. asynkrone databasekoblinger), sørg for at din DI-container og avhengighetsprovidere støtter asynkrone operasjoner.

Eksempel (Asynkron Avhengighet med `dependency_injector`):

            
import asyncio
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends

# Definer asynkron avhengighet
class AsyncDatabase:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    async def connect(self):
        print(f"Kobler til database: {self.connection_string}")
        await asyncio.sleep(0.1) # Simulerer tilkoblingstid

    async def fetch_data(self):
        await asyncio.sleep(0.1) # Simulerer databaseforespørsel
        return [{"id": 1, "name": "Async Element 1"}]

# Definer container
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    database = providers.Singleton(AsyncDatabase, connection_string=config.database_url)

# Opprett FastAPI-app
app = FastAPI()

# Konfigurer container
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__])

# Avhengighet for FastAPI
async def get_async_database(database: AsyncDatabase = Depends(container.database.provided)) -> AsyncDatabase:
    await database.connect()
    return database


# Endepunkt som bruker injisert avhengighet
@app.get("/async-items/")
async def read_async_items(database: AsyncDatabase = Depends(get_async_database)):
    data = await database.fetch_data()
    return data


@app.on_event("startup")
async def startup_event():
    # Container initialisering
    container.init_resources()

            

              
                Copy
              
            
          

Forklaring:

• AsyncDatabase-klassen definerer asynkrone metoder ved hjelp av async og await.
• get_async_database-avhengigheten er også definert som en asynkron funksjon.
• Endepunktfunksjonen read_async_items er merket som async og venter på resultatet av database.fetch_data().

Valg av Riktig Tilnærming

Den beste tilnærmingen for å bygge en avansert DI-container avhenger av kompleksiteten i applikasjonen din og dine spesifikke krav:

• For små til mellomstore prosjekter: FastAPIs innebygde DI eller en fabrikkfunksjonstilnærming med Depends kan være tilstrekkelig.
• For større, mer komplekse prosjekter: Et dedikert DI-bibliotek som dependency_injector tilbyr et omfattende sett med funksjoner for å administrere avhengigheter.
• For prosjekter som krever finmasket kontroll over DI-prosessen: Å implementere en egen DI-container kan være det beste alternativet.

Konklusjon

Dependency injection er en kraftig teknikk for å bygge skalerbare, vedlikeholdbare og testbare applikasjoner. Mens FastAPIs innebygde DI-system er utmerket for enkle brukstilfeller, kan en avansert DI-container arkitektur gi betydelige fordeler for mer komplekse prosjekter. Ved å velge riktig tilnærming og utnytte funksjonene til DI-biblioteker eller implementere en egen container, kan du lage et robust og fleksibelt avhengighetsstyringssystem som forbedrer den generelle kvaliteten og vedlikeholdbarheten av dine FastAPI-applikasjoner.

Globale Vurderinger

Ved utforming av DI-containere for globale applikasjoner, er det viktig å vurdere følgende:

• Lokalisering: Avhengigheter relatert til lokalisering (f.eks. språkinnstillinger, datoformater) bør administreres av DI-containeren for å sikre konsistens på tvers av ulike regioner.
• Tidssoner: Avhengigheter som håndterer tidssonekonverteringer bør injiseres for å unngå hardkoding av tidssoninformasjon.
• Valuta: Avhengigheter for valutaomregning og formatering bør administreres av containeren for å støtte ulike valutaer.
• Regionale Innstillinger: Andre regionale innstillinger, som tallformater og adresseformater, bør også administreres av DI-containeren.
• Multi-tenancy: For multi-tenant applikasjoner bør DI-containeren kunne levere ulike avhengigheter for ulike tenants. Dette kan oppnås ved å bruke skop eller egendefinert avhengighetsløsningslogikk.
• Samsvar og Sikkerhet: Sørg for at din avhengighetsstyringsstrategi samsvarer med relevante databeskyttelsesforskrifter (f.eks. GDPR, CCPA) og beste sikkerhetspraksis i ulike regioner. Håndter sensitive legitimasjon og konfigurasjoner sikkert innenfor containeren.

Ved å vurdere disse globale faktorene, kan du lage DI-containere som er godt egnet for å bygge applikasjoner som opererer i et globalt miljø.