מערכת תלויות של FastAPI: הזרקת תלויות מתקדמת

מערכת הזרקת התלויות (DI) של FastAPI היא אבן יסוד בעיצוב שלה, המקדמת מודולריות, יכולת בדיקה ושימושיות חוזרת. בעוד שהשימוש הבסיסי הוא פשוט, שליטה בטכניקות DI מתקדמות פותחת כוח וגמישות משמעותיים. מאמר זה מתעמק בהזרקת תלויות מתקדמת ב-FastAPI, ומכסה תלויות מותאמות אישית, היקפים, אסטרטגיות בדיקה ושיטות עבודה מומלצות.

הבנת היסודות

לפני שנצלול לנושאים מתקדמים, בואו נסכם במהירות את יסודות הזרקת התלויות של FastAPI:

• תלויות כפונקציות: תלויות מוצהרות כפונקציות פייתון רגילות.
• הזרקה אוטומטית: FastAPI מזריק אוטומטית תלויות אלה לפעולות נתיב בהתבסס על רמזי סוג.
• רמזי סוג כחוזים: רמזי סוג מגדירים את סוגי הקלט הצפויים עבור תלויות ופונקציות פעולת נתיב.
• תלויות היררכיות: תלויות יכולות להיות תלויות בתלויות אחרות, וליצור עץ תלויות.

הנה דוגמה פשוטה:

            
from fastapi import FastAPI, Depends

app = FastAPI()

def get_db():
    db = {"items": []}
    try:
        yield db
    finally:
        # Close the connection if needed
        pass

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

            

              
                Copy
              
            
          

בדוגמה זו, get_db היא תלות המספקת חיבור למסד נתונים. FastAPI קורא אוטומטית ל-get_db ומזריק את התוצאה לפונקציה read_items.

טכניקות תלות מתקדמות

1. שימוש במחלקות כתלויות

בעוד שפונקציות משמשות בדרך כלל, מחלקות יכולות לשמש גם כתלויות, ומאפשרות ניהול מצבים ושיטות מורכבות יותר. זה שימושי במיוחד כאשר עוסקים בחיבורי מסד נתונים, שירותי אימות או משאבים אחרים הדורשים אתחול וניקוי.

            
from fastapi import FastAPI, Depends

app = FastAPI()

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

    def create_connection(self):
        # Simulate a database connection
        print("Creating database connection...")
        return {"items": []}

    def close(self):
        # Simulate closing a database connection
        print("Closing database connection...")

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
              
            
          

בדוגמה זו, המחלקה Database מכילה את הלוגיקה של חיבור למסד הנתונים. התלות get_db יוצרת מופע של המחלקה Database ומחזירה את החיבור. בלוק ה-finally מבטיח שהחיבור ייסגר כראוי לאחר עיבוד הבקשה.

2. עקיפת תלויות

FastAPI מאפשרת לך לעקוף תלויות, וזה חיוני לבדיקות ופיתוח. אתה יכול להחליף תלות אמיתית במוק או סטוב כדי לבודד את הקוד שלך ולהבטיח תוצאות עקביות.

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Original dependency
def get_settings():
    # Simulate loading settings from a file or environment
    return {"api_key": "real_api_key"}

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

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

app.dependency_overrides[get_settings] = get_settings_override

# To revert back to the original:
# del app.dependency_overrides[get_settings]

            

              
                Copy
              
            
          

בדוגמה זו, התלות get_settings נעקפת באמצעות get_settings_override. זה מאפשר לך להשתמש במפתח API שונה למטרות בדיקה.

3. שימוש ב-contextvars עבור נתונים בהיקף בקשה

contextvars הוא מודול פייתון המספק משתנים מקומיים להקשר. זה שימושי לאחסון נתונים ספציפיים לבקשה, כגון מידע על אימות משתמש, מזהי בקשה או נתוני מעקב. שימוש ב-contextvars עם הזרקת התלויות של FastAPI מאפשר לך לגשת לנתונים אלה בכל היישום שלך.

            
import contextvars
from fastapi import FastAPI, Depends, Request
import uuid

app = FastAPI()

# Create a context variable for the request ID
request_id_var = contextvars.ContextVar("request_id")

# Middleware to set the request 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

# Dependency to access the request 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
              
            
          

בדוגמה זו, תוכנת ביניים מגדירה מזהה בקשה ייחודי לכל בקשה נכנסת. התלות get_request_id מאחזרת את מזהה הבקשה מההקשר contextvars. זה מאפשר לך לעקוב אחר בקשות ברחבי היישום שלך.

4. תלויות אסינכרוניות

FastAPI תומכת בצורה חלקה בתלויות אסינכרוניות. זה חיוני לפעולות קלט/פלט שאינן חוסמות, כגון שאילתות מסד נתונים או קריאות API חיצוניות. פשוט הגדר את פונקציית התלות שלך כפונקציה async def.

            
from fastapi import FastAPI, Depends
import asyncio

app = FastAPI()

async def get_data():
    # Simulate an asynchronous operation
    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
              
            
          

בדוגמה זו, התלות get_data היא פונקציה אסינכרונית המדמה עיכוב. FastAPI ממתין אוטומטית לתוצאה של התלות האסינכרונית לפני הזרקתה לפונקציה read_items.

5. שימוש בגנרטורים לניהול משאבים (חיבורי מסד נתונים, ידיות קבצים)

שימוש בגנרטורים (עם yield) מספק ניהול משאבים אוטומטי, המבטיח שמשאבים ייסגרו/ישוחררו כראוי באמצעות בלוק ה-finally גם אם מתרחשות שגיאות.

            
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
              
            
          

היקפי תלות ומחזורי חיים

הבנת היקפי התלות היא חיונית לניהול מחזור החיים של תלויות ולהבטחה שהמשאבים מוקצים ומשוחררים כראוי. FastAPI לא מציעה ישירות ביאורי היקף מפורשים כמו כמה מסגרות DI אחרות (לדוגמה, ה-@RequestScope, @ApplicationScope של Spring), אבל השילוב של איך אתה מגדיר תלויות ואיך אתה מנהל מצב משיג תוצאות דומות.

היקף בקשה

זהו ההיקף הנפוץ ביותר. כל בקשה מקבלת מופע חדש של התלות. זה מושג בדרך כלל על ידי יצירת אובייקט חדש בתוך פונקציית תלות והחזרתו, כפי שמוצג בדוגמה של מסד הנתונים קודם לכן. שימוש ב-contextvars עוזר גם להשיג היקף בקשה.

היקף יישום (סינגלטון)

מופע בודד של התלות נוצר ומשותף בין כל הבקשות לאורך מחזור החיים של היישום. זה נעשה לעתים קרובות באמצעות משתנים גלובליים או תכונות ברמת המחלקה.

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Singleton instance
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
              
            
          

היזהר בעת שימוש בתלויות בהיקף יישום עם מצב ניתן לשינוי, מכיוון ששינויים שבוצעו על ידי בקשה אחת יכולים להשפיע על בקשות אחרות. מנגנוני סנכרון (מנעולים וכו') עשויים להידרש אם ליישום שלך יש בקשות מקבילות.

היקף סשן (נתונים ספציפיים למשתמש)

שייך תלויות לסשנים של משתמשים. זה דורש מנגנון ניהול סשנים (לדוגמה, שימוש בעוגיות או JWT) ובדרך כלל כולל אחסון תלויות בנתוני הסשן.

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

app = FastAPI()

# In a real app, store sessions in a database or 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())} # Assign a random user 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
              
            
          

בדיקת תלויות

אחד היתרונות העיקריים של הזרקת תלויות הוא יכולת בדיקה משופרת. על ידי הפרדת רכיבים, אתה יכול בקלות להחליף תלויות במוק או סטוב במהלך הבדיקה.

1. עקיפת תלויות בבדיקות

כפי שהודגם קודם לכן, מנגנון dependency_overrides של FastAPI הוא אידיאלי לבדיקות. צור תלויות מוק המחזירות תוצאות צפויות והשתמש בהן כדי לבודד את הקוד שלך בבדיקה.

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

app = FastAPI()

# Original dependency
def get_external_data():
    # Simulate fetching data from an external 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"}

    # Clean up overrides
    app.dependency_overrides.clear()


            

              
                Copy
              
            
          

2. שימוש בספריות מוקינג

ספריות כמו unittest.mock מספקות כלים חזקים ליצירת אובייקטי מוק ושליטה בהתנהגותם. אתה יכול להשתמש במוקים כדי לדמות תלויות מורכבות ולאמת שהקוד שלך מקיים איתן אינטראקציה נכונה.

            
import unittest
from unittest.mock import MagicMock

# (Define the FastAPI app and get_external_data as above)

class TestReadData(unittest.TestCase):
    def test_read_data_with_mock(self):
        # Create a mock for the get_external_data dependency
        mock_get_external_data = MagicMock(return_value={"data": "Mocked data from unittest"})

        # Override the dependency with the mock
        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"})

        # Assert that the mock was called
        mock_get_external_data.assert_called_once()

        # Clean up overrides
        app.dependency_overrides.clear()

            

              
                Copy
              
            
          

3. הזרקת תלויות לבדיקות יחידה (מחוץ להקשר FastAPI)

אפילו בעת בדיקת יחידה של פונקציות מחוץ למטפלי נקודות הקצה של API, עקרונות הזרקת תלויות עדיין חלים. במקום להסתמך על Depends של FastAPI, הזרק ידנית את התלויות לפונקציה בבדיקה.

            
# Example function to test
def process_data(data_source):
    data = data_source.fetch_data()
    # ... process the data ...
    return processed_data

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

# Unit test
def test_process_data():
    mock_data_source = MockDataSource()
    result = process_data(mock_data_source)
    # Assertions on the result

            

              
                Copy
              
            
          

שיקולי אבטחה עם הזרקת תלויות

הזרקת תלויות, למרות שהיא מועילה, מציגה חששות אבטחה פוטנציאליים אם לא מיושמת בזהירות.

1. בלבול תלויות

ודא שאתה מושך תלויות ממקורות מהימנים. אמת את תקינות החבילה והשתמש במנהלי חבילות עם יכולות סריקת פגיעות. זהו עיקרון אבטחה כללי של שרשרת אספקת תוכנה, אך הוא מוחמר על ידי DI מכיוון שאתה עשוי להזריק רכיבים ממקורות מגוונים.

2. הזרקת תלויות זדוניות

שים לב לתלויות המקבלות קלט חיצוני ללא אימות נאות. תוקף יכול להזריק קוד או נתונים זדוניים באמצעות תלות שנפגעה. חיטוי את כל קלט המשתמשים ויישם מנגנוני אימות חזקים.

3. דליפת מידע דרך תלויות

ודא שתלויות לא חושפות בטעות מידע רגיש. סקור את הקוד והתצורה של התלויות שלך כדי לזהות פגיעויות פוטנציאליות לדליפת מידע.

4. סודות מקודדים

הימנע מקידוד קשיח של סודות (מפתחות API, סיסמאות למסד נתונים וכו') ישירות בקוד התלות שלך. השתמש במשתני סביבה או בכלי ניהול תצורה מאובטחים כדי לאחסן ולנהל סודות.

            
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("API_KEY environment variable not set.")
    return api_key

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

            

              
                Copy
              
            
          

אופטימיזציה של ביצועים עם הזרקת תלויות

הזרקת תלויות יכולה להשפיע על הביצועים אם לא משתמשים בה בתבונה. להלן כמה אסטרטגיות אופטימיזציה:

1. צמצם את עלות יצירת התלות

הימנע מיצירת תלויות יקרות בכל בקשה אם אפשר. אם תלות היא חסרת מצב או ניתנת לשיתוף בין בקשות, שקול להשתמש בהיקף סינגלטון או במטמון של מופע התלות.

2. אתחול עצל

אתחל תלויות רק כאשר הן נחוצות. זה יכול להפחית את זמן ההפעלה ואת צריכת הזיכרון, במיוחד עבור יישומים עם תלויות רבות.

3. שמירת תוצאות תלות במטמון

שמור במטמון את התוצאות של חישובי תלות יקרים אם סביר שהתוצאות יעשה בהן שימוש חוזר. השתמש במנגנוני שמירה במטמון (לדוגמה, Redis, Memcached) כדי לאחסן ולאחזר תוצאות תלות.

4. אופטימיזציה של גרף תלויות

נתח את גרף התלויות שלך כדי לזהות צווארי בקבוק פוטנציאליים. פשט את מבנה התלות והפחת את מספר התלויות אם אפשר.

5. תלויות אסינכרוניות עבור פעולות קלט/פלט מאוגדות

השתמש בתלויות אסינכרוניות בעת ביצוע פעולות חסימת קלט/פלט, כגון שאילתות מסד נתונים או קריאות API חיצוניות. זה מונע חסימה של השרשור הראשי ומשפר את היענות היישום הכוללת.

שיטות עבודה מומלצות עבור הזרקת תלויות של FastAPI

• שמור על תלויות פשוטות: שאף לתלויות קטנות וממוקדות המבצעות משימה בודדת. זה משפר את הקריאות, יכולת הבדיקה והתחזוקה.
• השתמש ברמזי סוג: נצל את רמזי הסוג כדי להגדיר בבירור את סוגי הקלט והפלט הצפויים של תלויות. זה משפר את בהירות הקוד ומאפשר ל-FastAPI לבצע בדיקת סוג סטטית.
• תעד תלויות: תעד את המטרה והשימוש בכל תלות. זה עוזר למפתחים אחרים להבין כיצד להשתמש ולתחזק את הקוד שלך.
• בדוק תלויות ביסודיות: כתוב בדיקות יחידה עבור התלויות שלך כדי להבטיח שהן מתנהגות כמצופה. זה עוזר למנוע באגים ולשפר את המהימנות הכוללת של היישום שלך.
• השתמש במוסכמות שמות עקביות: השתמש במוסכמות שמות עקביות עבור התלויות שלך כדי לשפר את קריאות הקוד.
• הימנע מתלויות מעגליות: תלויות מעגליות עלולות להוביל לקוד מורכב וקשה לאיתור באגים. שנה את הקוד שלך כדי למנוע תלויות מעגליות.
• שקול מיכלי הזרקת תלויות (אופציונלי): בעוד שהזרקת התלויות המובנית של FastAPI מספיקה לרוב המקרים, שקול להשתמש במיכל הזרקת תלויות ייעודי (לדוגמה, inject, autowire) עבור יישומים מורכבים יותר.

מסקנה

מערכת הזרקת התלויות של FastAPI היא כלי רב עוצמה המקדם מודולריות, יכולת בדיקה ושימושיות חוזרת. על ידי שליטה בטכניקות מתקדמות, כגון שימוש במחלקות כתלויות, עקיפת תלויות ושימוש ב-contextvars, אתה יכול לבנות API חזקים ומדרגיים. הבנת היקפי התלות ומחזורי החיים היא חיונית לניהול משאבים ביעילות. תמיד תן עדיפות לבדיקה יסודית של התלויות שלך כדי להבטיח את המהימנות והאבטחה של היישומים שלך. על ידי ביצוע שיטות עבודה מומלצות ושקילת השלכות אבטחה וביצועים פוטנציאליות, אתה יכול למנף את מלוא הפוטנציאל של מערכת הזרקת התלויות של FastAPI.