როგორ მუშაობს მოთხოვნის სასიცოცხლო ციკლი FastAPI-ში?

Question

IT Interview Practice · Accepted Answer

FastAPI მუშაობს **ASGI**-ზე, ამიტომ მოთხოვნა გადის ასინქრონულ pipeline-ში: ASGI სერვერი იღებს მას, middleware ახვევს, router ამთხვევს path-ს, **dependency-ები წყდება**, თქვენი path operation სრულდება, და დაბრუნებული მნიშვნელობა სერიალიზდება response-ში.

## ეტაპები

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── ამთხვევს method + path → path operation
   ▼
Dependencies (Depends)  ── sub-deps-ის გადაწყვეტა, security, yield-setup
   ▼
Path operation function  ── თქვენი handler სრულდება
   ▼
Response model  ── ვალიდაცია + სერიალიზაცია JSON-ში
   ▼
Background tasks  ── სრულდება response-ის გაგზავნის შემდეგ
   ▼
Response ──▶ client
```

1. **ASGI სერვერი** (uvicorn/hypercorn) იღებს კავშირს და გადასცემს `scope`-ს და `receive`/`send` callable-ებს app-ს.
2. **Middleware** შესვლისას მუშაობს გარედან შიგნით და გასვლისას შიგნიდან გარეთ (`BaseHTTPMiddleware` ან სუფთა ASGI middleware). CORS, GZip და მორგებული დროის გაზომვა აქ ცხოვრობს.
3. **Routing** ამთხვევს HTTP მეთოდს + path-ს path operation-თან; path/query/body პარამეტრებს ამოიღებს და ავალიდირებს **Pydantic**.
4. **Dependency injection** — `Depends(...)` წყვეტს თითოეულ dependency-ს (DB session, მიმდინარე მომხმარებელი, settings), მოთხოვნის ფარგლებში ქეშირებით. `yield`-ის მქონე dependency handler-ამდე ასრულებს setup-ს და მის შემდეგ teardown-ს.
5. **Path operation** — თქვენი `async def` (ან `def`, რომელიც threadpool-ში სრულდება) ასრულებს ბიზნეს-ლოგიკას.
6. **Response** — დაბრუნებული მნიშვნელობა გადაჰყავთ დეკლარირებულ `response_model`-ზე, ვალიდირდება და სერიალიზდება JSON-ში; გამოიყენება status code და header-ები.
7. **Background tasks**, რომლებიც `BackgroundTasks`-ის მეშვეობით არის რეგისტრირებული, სრულდება response-ის გაგზავნის *შემდეგ*.

```python
from fastapi import FastAPI, Depends, Request

app = FastAPI()

@app.middleware("http")
async def timing(request: Request, call_next):   # 2. middleware
    response = await call_next(request)
    response.headers["X-Time"] = "..."
    return response

async def get_db():                               # 4. dependency (yield)
    db = Session()
    try:
        yield db
    finally:
        db.close()

@app.get("/items/{id}")                           # 3. routing
async def read_item(id: int, db=Depends(get_db)): # 5. handler
    return db.get(Item, id)                        # 6. სერიალიზებული response_model-ის მეშვეობით
```

გამონაკლისებს იჭერს **exception handler**-ები (`@app.exception_handler(...)` / `HTTPException`), რომლებიც მათ response-ებად აქცევს, ნაცვლად იმისა, რომ მოთხოვნა ჩამოვარდეს.

## რატომ არის ეს მნიშვნელოვანი

მოთხოვნის სასიცოცხლო ციკლი არის ის, სადაც FastAPI-ის მთავარი ფუნქციები რეალურად ხდება: async I/O, Pydantic-ვალიდაცია და dependency injection ყველა კონკრეტულ ეტაპს ერთვის. თანმიმდევრობის ცოდნა — middleware, შემდეგ routing, შემდეგ dependency-ები, შემდეგ handler, შემდეგ სერიალიზაცია — საშუალებას გაძლევთ განათავსოთ განივი ლოგიკა სწორ ადგილას (auth როგორც dependency, დროის გაზომვა როგორც middleware, გაწმენდა `yield` dependency-ში), გამართოთ, თუ რატომ ისვრება ვალიდაციის ან auth-ის შეცდომა თქვენი კოდის გაშვებამდე, და აიცილოთ event loop-ის დაბლოკვა async handler-ის შიგნით.

ეტაპები

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები