FastAPI Dependency Injection: Avancerad Arkitektur för DI-Containrar

FastAPI, med sin intuitiva design och kraftfulla funktioner, har blivit en favorit för att bygga moderna webb-API:er i Python. En av dess kärnstyrkor ligger i dess sömlösa integration med dependency injection (DI), vilket gör det möjligt för utvecklare att skapa löst kopplade, testbara och underhållbara applikationer. Medan FastAPI:s inbyggda DI-system är utmärkt för enkla användningsfall, drar mer komplexa projekt ofta nytta av en mer strukturerad och avancerad arkitektur för DI-containrar. Denna artikel utforskar olika strategier för att bygga en sådan arkitektur och ger praktiska exempel och insikter för att designa robusta och skalbara applikationer.

Förståelse för Dependency Injection (DI) och Inversion of Control (IoC)

Innan vi dyker in i avancerade arkitekturer för DI-containrar, låt oss klargöra de grundläggande begreppen:

• Dependency Injection (DI): Ett designmönster där beroenden tillhandahålls till en komponent från externa källor istället för att skapas internt. Detta främjar lös koppling, vilket gör komponenter lättare att testa och återanvända.
• Inversion of Control (IoC): En bredare princip där kontrollen över objektskapande och hantering inverteras – delegeras till ett ramverk eller en container. DI är en specifik typ av IoC.

FastAPI har inbyggt stöd för DI genom sitt beroendesystem. Du definierar beroenden som anropningsbara objekt (funktioner, klasser, etc.), och FastAPI löser automatiskt upp och injicerar dem i dina endpoint-funktioner eller andra beroenden.

Exempel (Grundläggande FastAPI DI):

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Beroende
def get_db():
    db = {"items": []}  # Simulera en databasanslutning
    try:
        yield db
    finally:
        # Stäng databasanslutningen (om det behövs)
        pass


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

            

              
                Copy
              
            
          

I detta exempel är get_db ett beroende som tillhandahåller en databasanslutning. FastAPI anropar automatiskt get_db och injicerar resultatet (db-ordboken) i endpoint-funktionen read_items.

Varför en avancerad DI-container?

FastAPI:s inbyggda DI fungerar bra för enkla projekt, men när applikationer växer i komplexitet erbjuder en mer sofistikerad DI-container flera fördelar:

• Centraliserad hantering av beroenden: En dedikerad container utgör en enda sanningskälla för alla beroenden, vilket gör det lättare att hantera och förstå applikationens beroenden.
• Konfiguration och livscykelhantering: Containern kan hantera konfigurationen och livscykeln för beroenden, såsom att skapa singletons, hantera anslutningar och frigöra resurser.
• Testbarhet: En avancerad container förenklar testning genom att låta dig enkelt ersätta beroenden med mock-objekt eller test-dubletter.
• Frikoppling: Främjar större frikoppling mellan komponenter, vilket minskar beroenden och förbättrar kodens underhållbarhet.
• Utbyggbarhet: En utbyggbar container låter dig lägga till anpassade funktioner och integrationer vid behov.

Strategier för att bygga en avancerad DI-container

Det finns flera tillvägagångssätt för att bygga en avancerad DI-container i FastAPI. Här är några vanliga strategier:

1. Använda ett dedikerat DI-bibliotek (t.ex. injector, dependency_injector)

Flera kraftfulla DI-bibliotek finns tillgängliga för Python, såsom injector och dependency_injector. Dessa bibliotek erbjuder en omfattande uppsättning funktioner för att hantera beroenden, inklusive:

• Binding: Definiera hur beroenden löses upp och injiceras.
• Scopes: Kontrollera livscykeln för beroenden (t.ex. singleton, transient).
• Konfiguration: Hantera konfigurationsinställningar för beroenden.
• AOP (Aspect-Oriented Programming): Fånga upp metodanrop för tvärgående aspekter.

Exempel med dependency_injector

dependency_injector är ett populärt val för att bygga DI-containrar. Låt oss illustrera dess användning med ett exempel:

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

# Definiera beroenden
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string
        # Initiera databasanslutning
        print(f"Connecting to database: {self.connection_string}")

    def get_items(self):
        # Simulera hämtning av objekt från databasen
        return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]


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

    def get_all_users(self):
        # Simulerar en databasförfrågan för att hämta alla användare
        return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]

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

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

# Skapa FastAPI-app
app = FastAPI()

# Konfigurera container (från en miljövariabel)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # möjliggör injicering av beroenden i FastAPI-endpoints

# Beroende för FastAPI
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Endpoint som använder injicerat beroende
@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
              
            
          

Förklaring:

• Vi definierar våra beroenden (Database, UserRepository, Settings) som vanliga Python-klasser.
• Vi skapar en Container-klass som ärver från containers.DeclarativeContainer. Denna klass definierar beroendena och deras providers (t.ex. providers.Singleton för singletons, providers.Factory för att skapa nya instanser varje gång).
• Raden container.wire([__name__]) möjliggör dependency injection i FastAPI-endpoints.
• Funktionen get_user_repository är ett FastAPI-beroende som använder container.user_repository.provided för att hämta UserRepository-instansen från containern.
• Endpoint-funktionen read_users injicerar UserRepository-beroendet.
• config låter dig externalisera konfigurationerna för beroenden. Den kan sedan komma från miljövariabler, konfigurationsfiler etc.
• startup_event används för att initialisera de resurser som hanteras i containern.

2. Implementera en anpassad DI-container

För mer kontroll över DI-processen kan du implementera en anpassad DI-container. Detta tillvägagångssätt kräver mer ansträngning men låter dig skräddarsy containern efter dina specifika behov.

Exempel på grundläggande anpassad 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"Dependency {dependency_type} not registered.")

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


# Exempelberoenden
class PaymentGateway:
    def process_payment(self, amount: float) -> bool:
        print(f"Processing payment of ${amount}")
        return True # Simulera lyckad betalning


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


# Exempelanvändning
container = Container()
container.singleton(PaymentGateway, PaymentGateway)
container.singleton(NotificationService, NotificationService)

app = FastAPI()

# FastAPI-beroende
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("Purchase successful!")
        return {"message": "Purchase successful"}
    else:
        return {"message": "Purchase failed"}

            

              
                Copy
              
            
          

Förklaring:

• Klassen Container hanterar en ordbok med beroenden och deras providers.
• Metoden register registrerar ett beroende med sin provider.
• Metoden resolve löser upp ett beroende genom att anropa dess provider.
• Metoden singleton registrerar ett beroende och skapar en enda instans av det.
• FastAPI-beroenden skapas med hjälp av en lambda-funktion för att lösa upp beroenden från containern.

3. Använda FastAPI:s Depends med en fabriksfunktion

Istället för en fullfjädrad DI-container kan du använda FastAPI:s Depends tillsammans med fabriksfunktioner för att uppnå en viss nivå av beroendehantering. Detta tillvägagångssätt är enklare än att implementera en anpassad container men ger fortfarande vissa fördelar jämfört med att direkt instansiera beroenden inuti endpoint-funktioner.

            
from fastapi import FastAPI, Depends
from typing import Callable

# Definiera beroenden
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"Sending email to {recipient} via {self.smtp_server}: {subject} - {body}")


# Fabriksfunktion för EmailService
def create_email_service(smtp_server: str) -> EmailService:
    return EmailService(smtp_server=smtp_server)


# FastAPI
app = FastAPI()

# FastAPI-beroende, utnyttjar fabriksfunktion och 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": "Email sent!"}

            

              
                Copy
              
            
          

Förklaring:

• Vi definierar en fabriksfunktion (create_email_service) som skapar instanser av EmailService-beroendet.
• Beroendet get_email_service använder Depends och en lambda för att anropa fabriksfunktionen och tillhandahålla en instans av EmailService.
• Endpoint-funktionen send_email injicerar EmailService-beroendet.

Avancerade överväganden

1. Omfång och livscykler

DI-containrar erbjuder ofta funktioner för att hantera livscykeln för beroenden. Vanliga omfång (scopes) inkluderar:

• Singleton: En enda instans av beroendet skapas och återanvänds under hela applikationens livstid. Detta är lämpligt för beroenden som är tillståndslösa eller har globalt omfång.
• Transient: En ny instans av beroendet skapas varje gång det begärs. Detta är lämpligt för beroenden som är tillståndsfulla eller behöver isoleras från varandra.
• Request: En enda instans av beroendet skapas för varje inkommande förfrågan. Detta är lämpligt för beroenden som behöver bibehålla tillstånd inom ramen för en enskild förfrågan.

Biblioteket dependency_injector har inbyggt stöd för omfång. För anpassade containrar måste du implementera logiken för omfångshantering själv.

2. Konfiguration

Beroenden kräver ofta konfigurationsinställningar, såsom anslutningssträngar till databaser, API-nycklar och feature flags. DI-containrar kan hjälpa till att hantera dessa inställningar genom att erbjuda ett centraliserat sätt att komma åt och injicera konfigurationsvärden.

I exemplet med dependency_injector tillåter config-providern konfiguration från miljövariabler. För anpassade containrar kan du ladda konfiguration från filer eller miljövariabler och lagra dem i containern.

3. Testning

En av de främsta fördelarna med DI är förbättrad testbarhet. Med en DI-container kan du enkelt ersätta verkliga beroenden med mock-objekt eller test-dubletter under testning.

Exempel (Testning 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

# Definiera beroenden (samma som tidigare)
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    def get_items(self):
        return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 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

# Definiera container (samma som tidigare)
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)

# Skapa FastAPI-app (samma som tidigare)
app = FastAPI()

# Konfigurera container (från en miljövariabel)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # möjliggör injicering av beroenden i FastAPI-endpoints

# Beroende för FastAPI
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Endpoint som använder injicerat beroende (samma som tidigare)
@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():
    # Ersätt databasberoendet med en mock
    database_mock = MagicMock(spec=Database)
    database_mock.get_items.return_value = [{"id": 3, "name": "Test Item"}]

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

    # Ersätt container med mock-beroenden
    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 User"}]

            

              
                Copy
              
            
          

Förklaring:

• Vi skapar ett mock-objekt för Database-beroendet med hjälp av MagicMock.
• Vi ersätter database-providern i containern med mock-objektet genom att använda container.database.override().
• Testfunktionen test_read_items använder nu det mockade databasberoendet.
• Efter att testet har körts återställs det ersatta beroendet i containern.

4. Asynkrona beroenden

FastAPI är byggt ovanpå asynkron programmering (async/await). När du arbetar med asynkrona beroenden (t.ex. asynkrona databasanslutningar), se till att din DI-container och dina beroende-providers stöder asynkrona operationer.

Exempel (Asynkront beroende med dependency_injector):

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

# Definiera asynkront beroende
class AsyncDatabase:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    async def connect(self):
        print(f"Connecting to database: {self.connection_string}")
        await asyncio.sleep(0.1) # Simulera anslutningstid

    async def fetch_data(self):
        await asyncio.sleep(0.1) # Simulera databasfråga
        return [{"id": 1, "name": "Async Item 1"}]

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

# Skapa FastAPI-app
app = FastAPI()

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

# Beroende för FastAPI
async def get_async_database(database: AsyncDatabase = Depends(container.database.provided)) -> AsyncDatabase:
    await database.connect()
    return database


# Endpoint som använder injicerat beroende
@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
              
            
          

Förklaring:

• Klassen AsyncDatabase definierar asynkrona metoder med async och await.
• Beroendet get_async_database är också definierat som en asynkron funktion.
• Endpoint-funktionen read_async_items är markerad som async och inväntar resultatet av database.fetch_data().

Välja rätt tillvägagångssätt

Det bästa tillvägagångssättet för att bygga en avancerad DI-container beror på komplexiteten i din applikation och dina specifika krav:

• För små till medelstora projekt: FastAPI:s inbyggda DI eller ett tillvägagångssätt med fabriksfunktioner och Depends kan vara tillräckligt.
• För större, mer komplexa projekt: Ett dedikerat DI-bibliotek som dependency_injector erbjuder en omfattande uppsättning funktioner för att hantera beroenden.
• För projekt som kräver finkornig kontroll över DI-processen: Att implementera en anpassad DI-container kan vara det bästa alternativet.

Slutsats

Dependency injection är en kraftfull teknik för att bygga skalbara, underhållbara och testbara applikationer. Medan FastAPI:s inbyggda DI-system är utmärkt för enkla användningsfall, kan en avancerad arkitektur för DI-containrar ge betydande fördelar för mer komplexa projekt. Genom att välja rätt tillvägagångssätt och utnyttja funktionerna i DI-bibliotek eller implementera en anpassad container kan du skapa ett robust och flexibelt system för beroendehantering som förbättrar den övergripande kvaliteten och underhållbarheten i dina FastAPI-applikationer.

Globala överväganden

När man designar DI-containrar för globala applikationer är det viktigt att ta hänsyn till följande:

• Lokalisering: Beroenden relaterade till lokalisering (t.ex. språkinställningar, datumformat) bör hanteras av DI-containern för att säkerställa konsekvens över olika regioner.
• Tidszoner: Beroenden som hanterar tidszonskonverteringar bör injiceras för att undvika hårdkodad tidszonsinformation.
• Valuta: Beroenden för valutakonvertering och formatering bör hanteras av containern för att stödja olika valutor.
• Regionala inställningar: Andra regionala inställningar, såsom talformat och adressformat, bör också hanteras av DI-containern.
• Multi-tenancy: För applikationer med flera hyresgäster (multi-tenant) bör DI-containern kunna tillhandahålla olika beroenden för olika hyresgäster. Detta kan uppnås genom att använda omfång eller anpassad logik för att lösa upp beroenden.
• Efterlevnad och säkerhet: Säkerställ att din strategi för beroendehantering följer relevanta dataskyddsförordningar (t.ex. GDPR, CCPA) och bästa praxis för säkerhet i olika regioner. Hantera känsliga autentiseringsuppgifter och konfigurationer säkert inom containern.

Genom att ta hänsyn till dessa globala faktorer kan du skapa DI-containrar som är väl lämpade för att bygga applikationer som verkar i en global miljö.