ওয়েব ব্যাকএন্ড — FastAPI-র শুরু

১ · ব্যাকএন্ড কী — অর্ডার নেওয়ার কাউন্টার

পর্ব ৪৭-এ আপনি ছিলেন client-এর আসনে: Python দিয়ে অন্যের সার্ভারে request পাঠিয়েছেন, উত্তর হিসেবে JSON পেয়েছেন। এই পর্বে আসন বদলাচ্ছি। এবার আপনি সেই সার্ভার — যার কাছে অন্যরা request পাঠাবে। মোবাইল অ্যাপ, ওয়েবসাইটের JavaScript, অন্য কোনো প্রোগ্রাম, এমনকি পর্ব ৪৭-এর মতো একটি Python স্ক্রিপ্ট — সবাই আপনার প্রোগ্রামকে প্রশ্ন করবে, আর আপনার প্রোগ্রাম উত্তর দেবে।

সার্ভারের দিকের এই প্রোগ্রামটিকে বলে backend. আর ব্যবহারকারী যা চোখে দেখেন — বোতাম, ফর্ম, পেজ — সেটি frontend. সংজ্ঞাটি খুব সরল: ব্যাকএন্ড হলো একটি প্রোগ্রাম, যে HTTP request-এর অপেক্ষায় বসে থাকে, আর প্রতিটির উত্তর দেয়। এর বেশি রহস্য নেই।

পর্ব ৪৭-এ দেখেছেন, একটি HTTP request-এ থাকে একটি method (GET, POST, PUT, DELETE…), একটি ঠিকানা বা path (/products/7), কিছু header, আর কখনো একটি body (সাধারণত JSON). Response-এ থাকে একটি status code (200 ঠিক আছে, 404 পাওয়া যায়নি…), header আর body. সার্ভারের দিকে প্রতিটি request-এর যাত্রা চার ধাপের:

1. Request আসে: নেটওয়ার্ক থেকে কাঁচা বাইট আসে; web server সেগুলো পড়ে method, path, header, body আলাদা করে।
2. Router মেলায়: routing — “GET /products/7” কোন ফাংশনের দায়িত্বে? path থেকে 7-এর মতো অংশও আলাদা করে।
3. Handler কাজ করে: আপনার লেখা ফাংশন — ডেটা খোঁজে, হিসাব করে, ডেটাবেসে লেখে। একে বলে endpoint বা route handler.
4. Response ফেরে: ফলটি JSON-এ রূপান্তর (serialization), সাথে সঠিক status code, তারপর নেটওয়ার্কে ফেরত।

কোনো ফ্রেমওয়ার্ক ছাড়া, শুধু standard library দিয়ে, এই চার ধাপের মাঝের দুটি — router আর handler — নিজের হাতে লিখে দেখি। নেটওয়ার্ক লাগবে না; আমরা request-কে শুধু একটি method আর একটি path হিসেবে ফাংশনে পাঠাব:

import json
import re

products = {7: {"name": "চাল (৫ কেজি)", "price": 420}}
def get_product(product_id: str):
    if not product_id.isdecimal():                # FastAPI এটা নিজেই করে
        return 422, {"detail": "product_id must be an integer"}
    if int(product_id) not in products:
        return 404, {"detail": "প্রোডাক্ট পাওয়া যায়নি"}
    return 200, products[int(product_id)]

routes = [("GET", re.compile(r"/products/(?P<product_id>[^/]+)"), get_product)]
def handle(method: str, path: str):               # ছোট্ট একটি router
    for route_method, pattern, handler in routes:
        match = pattern.fullmatch(path)
        if match and route_method == method:
            return handler(**match.groupdict())
    return 404, {"detail": "Not Found"}

for path in ["/products/7", "/products/abc", "/products/99", "/orders"]:
    status, body = handle("GET", path)
    print(path, "→", status, json.dumps(body, ensure_ascii=False))

২ · ফ্রেমওয়ার্ক কেন — WSGI, ASGI আর Django, Flask, FastAPI

একটি web framework হলো এমন একটি লাইব্রেরি, যা request পড়া, routing, JSON রূপান্তর, যাচাই, error সামলানো, cookie, নিরাপত্তার header — এই সব সাধারণ কাজ আগে থেকেই করে রাখে। আপনি শুধু handler ফাংশনগুলো লেখেন। Library আর framework-এর পার্থক্য নিয়ে একটি পুরোনো কথা আছে — “library-কে আপনি ডাকেন, framework আপনাকে ডাকে”। ব্যাকএন্ডে তা আক্ষরিক সত্য: request এলে ফ্রেমওয়ার্ক আপনার ফাংশন ডাকে।

WSGI আর ASGI — সার্ভার আর অ্যাপের মাঝের চুক্তি

একটি প্রশ্ন থেকে যায়: নেটওয়ার্ক থেকে বাইট পড়ে কে, আর আপনার Python কোড ডাকে কে? এই দুটি কাজ আলাদা প্রোগ্রাম করে। একটি server (যেমন Gunicorn বা Uvicorn) socket খুলে বাইট পড়ে; আর আপনার application (Django, Flask বা FastAPI দিয়ে লেখা) শুধু Python object নিয়ে কাজ করে। দুজনের কথা বলার জন্য একটি নির্দিষ্ট চুক্তি দরকার। Python-এ সেই চুক্তির নাম WSGI (Web Server Gateway Interface, PEP 333, ২০০৩): application হলো একটি সাধারণ ফাংশন, যে একটি dict (environ — request-এর সব তথ্য) আর একটি start_response ফাংশন নেয়, আর body-র বাইট ফেরত দেয়। চুক্তিটি এতই সরল যে নেটওয়ার্ক ছাড়াই নিজে ডেকে দেখা যায়:

import io
import json

def app(environ, start_response):                 # একটি WSGI application
    raw = environ["wsgi.input"].read(int(environ.get("CONTENT_LENGTH") or 0))
    try:
        data = json.loads(raw)
        ok = isinstance(data["price"], (int, float)) and data["price"] > 0
    except (json.JSONDecodeError, KeyError, TypeError):
        ok = False
    status = "201 Created" if ok else "422 Unprocessable Content"
    body = {"created": data} if ok else {"detail": "price: ধনাত্মক সংখ্যা দিন"}
    start_response(status, [("Content-Type", "application/json")])
    return [json.dumps(body, ensure_ascii=False).encode()]

for text in ['{"name": "ডাল", "price": 140}', '{"name": "ডাল", "price": -5}',
             '{"name": "ডাল"}', 'দাম ১৪০ টাকা']:
    raw = text.encode()                           # নেটওয়ার্ক ছাড়াই নকল request
    environ = {"REQUEST_METHOD": "POST", "PATH_INFO": "/products",
               "CONTENT_LENGTH": str(len(raw)), "wsgi.input": io.BytesIO(raw)}
    chunks = app(environ, lambda status, headers: print(status, end=" | "))
    print(b"".join(chunks).decode())

WSGI-র একটি সীমা আছে: প্রতিটি request একটি ফাংশন-ডাক, যা শেষ না হওয়া পর্যন্ত সেই worker আটকে থাকে। একসাথে হাজারো ধীর সংযোগ (chat, WebSocket, অন্য API-র উত্তরের অপেক্ষা) সামলাতে এটি অদক্ষ। তাই এসেছে ASGI (Asynchronous Server Gateway Interface) — একই ধারণা, কিন্তু application একটি async ফাংশন, যা পর্ব ৪২-এর event loop-এ চলে। একটি request যখন ডেটাবেস বা অন্য সার্ভারের উত্তরের অপেক্ষায়, তখন একই process অন্য request-এর কাজ এগিয়ে নিতে পারে। Uvicorn একটি ASGI server; FastAPI একটি ASGI framework.

তিনটি বড় ফ্রেমওয়ার্ক — কোনটি কখন

সরল নিয়ম: HTML পেজ আর admin প্যানেলসহ পুরো একটি ওয়েবসাইট দরকার হলে Django; শুধু JSON API — বিশেষ করে মোবাইল অ্যাপ বা AI মডেলের জন্য — হলে FastAPI; ছোট কিছু, বা পুরোনো Flask প্রজেক্টে কাজ হলে Flask. তিনটিই পরিণত, বড় প্রতিষ্ঠানে ব্যবহৃত, আর যেকোনোটিতে ভালো ব্যাকএন্ড বানানো যায়। এই পর্বে FastAPI বেছে নিচ্ছি দুটি কারণে: এটি পর্ব ৩৫-এর decorator আর পর্ব ৩৭-এর type hint-কে সরাসরি কাজে লাগায়, আর এর কোড ছোট বলে পুরো ধারণাটি এক পর্বে দেখানো যায়। ফ্রেমওয়ার্কগুলোর গভীর তুলনা, MVC প্যাটার্ন আর অন্য ভাষার ফ্রেমওয়ার্ক দেখতে পারেন আমাদের Full-Stack Web Frameworks কোর্সে।

৩ · FastAPI-র প্রথম অ্যাপ — hello world, uvicorn আর /docs

python -m venv .venv
.venv\Scripts\activate            # Linux/macOS: source .venv/bin/activate
pip install "fastapi[standard]"   # FastAPI + uvicorn + fastapi CLI

এবার main.py নামে একটি ফাইল:

from fastapi import FastAPI

app = FastAPI(title="দোকানের প্রোডাক্ট API")

@app.get("/")
def home():
    return {"message": "দোকান খোলা"}

মাত্র পাঁচ লাইন, কিন্তু প্রতিটির অর্থ আছে। app = FastAPI() একটি ASGI application বানাল — এটিই server ডাকবে। @app.get("/") হলো পর্ব ৩৫-এর decorator, তবে decorator factory: app.get("/") ডাকলে একটি decorator ফেরত আসে, যা home ফাংশনটিকে router-এর তালিকায় “GET / এলে একে ডাকো” হিসেবে নিবন্ধন করে, আর ফাংশনটি অপরিবর্তিত ফেরত দেয়। ঠিক পর্ব ৩৫-এর registry pattern. আর handler একটি সাধারণ dict ফেরত দিয়েছে — FastAPI নিজেই সেটিকে JSON-এ বদলাবে আর 200 status দেবে।

চালানোর কমান্ডটি ধাপে ধাপে দেখুন:

Server চালু হলে ব্রাউজারে http://127.0.0.1:8000/ খুললে দেখবেন {"message":"দোকান খোলা"}. 127.0.0.1 মানে “এই কম্পিউটারই” — আপাতত শুধু আপনিই দেখতে পাচ্ছেন।

/docs — নিজে থেকে তৈরি ডকুমেন্টেশন

এবার খুলুন http://127.0.0.1:8000/docs. আপনি এক লাইনও না লিখে একটি পূর্ণ ইন্টারঅ্যাকটিভ ডকুমেন্টেশন পেজ পাবেন: প্রতিটি endpoint, কী parameter নেয়, কী ফেরত দেয়, আর একটি “Try it out” বোতাম — ব্রাউজার থেকেই request পাঠিয়ে দেখা যায়। এটি তৈরি হয় OpenAPI নামের একটি মানক বর্ণনা থেকে, যা FastAPI আপনার route আর type hint পড়ে /openapi.json-এ বানায়; আর পেজটি দেখায় Swagger UI. বিকল্প চেহারা আছে /redoc-এ।

৪ · Path আর query parameter — type hint থেকেই যাচাই

অংশ ১-এর ছোট router-এ আমরা নিজের হাতে path থেকে id বের করেছিলাম, সংখ্যা কি না দেখেছিলাম, ৪২২ ফেরত দিয়েছিলাম। FastAPI-তে একই কাজ:

products = {7: {"id": 7, "name": "চাল (৫ কেজি)", "price": 420.0, "stock": 12}}

@app.get("/products/{product_id}")
def get_product(product_id: int):
    return products[product_id]          # আপাতত না পাওয়ার ঘটনা বাদ

Path-এর {product_id} অংশটি একটি path parameter — ঠিকানার একটি পরিবর্তনশীল টুকরো। FastAPI দেখে ফাংশনেও একই নামের parameter আছে, আর তার type hint int. পর্ব ৩৭-এ বলেছিলাম, Python নিজে hint যাচাই করে না, কিন্তু কিছু লাইব্রেরি চালানোর সময় hint পড়ে কাজ করে। FastAPI ঠিক সেই লাইব্রেরি: hint পড়ে সে জানে "7" string-কে 7 int-এ বদলাতে হবে, আর না পারলে আপনার ফাংশন ডাকবেই না। দুটি request-এর যাত্রা পাশাপাশি দেখুন:

GET /products/7 HTTP/1.1
Host: 127.0.0.1:8000
Accept: application/json

GET  /                       → home
GET  /products/{product_id}  → get_product   ✔
POST /products               → create_product
product_id = "7"   (এখনো একটি str)

"7"  → int → 7      ✔ ফাংশন ডাকা যাবে

HTTP/1.1 200 OK
content-type: application/json

{"id": 7, "name": "চাল (৫ কেজি)", "price": 420.0, "stock": 12}

HTTP/1.1 422 Unprocessable Content

{"detail": [{"type": "int_parsing",
             "loc": ["path", "product_id"],
             "msg": "Input should be a valid integer, unable
                     to parse string as an integer",
             "input": "abc"}]}

Query parameter — ঐচ্ছিক ছাঁকনি

URL-এর ?-এর পরের অংশ হলো query parameter: /products?max_price=200&limit=5. FastAPI-র নিয়ম খুব সরল — ফাংশনের যে parameter path-এ নেই, সেটি query parameter. Default থাকলে ঐচ্ছিক, না থাকলে বাধ্যতামূলক:

@app.get("/products")
def list_products(max_price: float | None = None, limit: int = 10):
    items = list(products.values())
    if max_price is not None:
        items = [p for p in items if p["price"] <= max_price]
    return items[:limit]

max_price: float | None = None — পর্ব ৩৭-এর union type: দাম দিলে float, না দিলে None, আর তখন ছাঁকনি নেই। limit: int = 10 — না দিলে ১০টি। /products?limit=ten পাঠালে আবার ৪২২, এবার "loc": ["query", "limit"]. ব্যবহার বুঝে বাছুন: নির্দিষ্ট একটি জিনিস চিহ্নিত করতে path (/products/7, /results/123456), তালিকা ছাঁকতে, সাজাতে বা পাতা ভাগ করতে query (?max_price=200, ?page=2).

৫ · Request body আর pydantic model — নতুন প্রোডাক্ট যোগ করা

GET শুধু পড়ে। নতুন প্রোডাক্ট যোগ করতে client পাঠায় POST, আর প্রোডাক্টের তথ্য থাকে request-এর body-তে, JSON হিসেবে। এই body-র “আকার” বলে দিতে FastAPI ব্যবহার করে pydantic-এর model — দেখতে পর্ব ৩২-এর dataclass-এর মতো, কিন্তু চালানোর সময় সত্যিই যাচাই করে:

from fastapi import FastAPI, status
from pydantic import BaseModel, Field

class ProductIn(BaseModel):                       # client যা পাঠাবে
    name: str = Field(min_length=1, max_length=50)
    price: float = Field(gt=0)                    # শূন্যের বেশি
    stock: int = Field(default=0, ge=0)           # না দিলে ০

class Product(ProductIn):                         # সার্ভার যা ফেরত দেবে
    id: int

@app.post("/products", status_code=status.HTTP_201_CREATED)
def create_product(data: ProductIn) -> Product:
    global next_id
    product = Product(id=next_id, **data.model_dump())
    products[next_id] = product
    next_id += 1
    return product

এখানে নিয়মটি: parameter-এর type যদি একটি pydantic model হয়, FastAPI ধরে নেয় সেটি আসবে request body থেকে। Field(gt=0) মানে “greater than 0”, ge=0 মানে “শূন্য বা বেশি”। দুটি আলাদা model লক্ষ করুন — ProductIn-এ id নেই, কারণ id দেবে সার্ভার, client নয়। Client যদি নিজে "id": 1 পাঠায়, ProductIn সেটি ফেলে দেবে (pydantic-এর স্বাভাবিক আচরণে অচেনা field উপেক্ষিত হয়)। এটি একটি ছোট কিন্তু গুরুত্বপূর্ণ নিরাপত্তা-নকশা: client যা ঠিক করার অধিকার রাখে না, model-এ সেটি রাখবেন না। তিনটি আলাদা body পাঠালে কী হয়, দেখুন:

1class ProductIn(BaseModel):2    name: str = Field(min_length=1, max_length=50)3    price: float = Field(gt=0)4    stock: int = Field(default=0, ge=0)56@app.post("/products", status_code=201)7def create_product(data: ProductIn) -> Product:8    product = Product(id=next_id, **data.model_dump())9    ...10    return product

Response model — কী ফেরত যাবে, তাও চুক্তি

-> Product return hint শুধু লেবেল নয়। FastAPI এটিকে response model হিসেবে ব্যবহার করে: ফেরত দেওয়া ডেটা ওই model দিয়ে যাচাই আর ছাঁকা হয়, আর /docs-এ response-এর আকার দেখানো হয়। ছাঁকার অংশটিই সবচেয়ে কাজের। ধরুন ভেতরের ডেটায় একটি cost_price (কেনা দাম) আছে, যা ক্রেতার দেখার কথা নয়:

class ProductPublic(BaseModel):
    id: int
    name: str
    price: float

DB = {7: {"id": 7, "name": "চাল", "price": 420.0, "cost_price": 380.0}}

@app.get("/products/{pid}", response_model=ProductPublic)
def get_p(pid: int):
    return DB[pid]          # cost_price-সহ পুরো dict ফেরত দিলাম

# GET /products/7  →  200  {"id": 7, "name": "চাল", "price": 420.0}

Handler পুরো dict ফেরত দিলেও response-এ cost_price নেই — model-এ যা নেই, তা বাইরে যায় না। ব্যবহারকারীর ডেটায় এটি আরও জরুরি: একটি User object-এ password-এর hash থাকে, কিন্তু UserPublic model-এ থাকবে শুধু নাম আর ইমেইল। ভুল করে গোপন তথ্য পাঠানোর বিরুদ্ধে এটি একটি দ্বিতীয় দেয়াল।

৬ · Status code, HTTPException আর পুরো CRUD API

অংশ ৪-এর get_product-এ একটি বাগ রেখে এসেছিলাম: products[product_id] চাবি না পেলে KeyError. FastAPI তখন কী করে? Exception ধরা না পড়লে client পায় 500 Internal Server Error — অর্থাৎ “সার্ভারের দোষ”। অথচ আসলে দোষ কারও নয়, প্রোডাক্টটি শুধু নেই; সঠিক উত্তর 404 Not Found. Status code-গুলো একটি ভাষা, আর client (মোবাইল অ্যাপ, অন্য প্রোগ্রাম) এই ভাষা পড়েই সিদ্ধান্ত নেয় — আবার চেষ্টা করবে, ব্যবহারকারীকে “পাওয়া যায়নি” দেখাবে, নাকি লগইন পেজে পাঠাবে।

নিয়মটি মনে রাখুন: ৪xx মানে client-এর দিক থেকে সমস্যা, ৫xx মানে সার্ভারের দিক থেকে। FastAPI-তে ইচ্ছা করে একটি ৪xx উত্তর দিতে HTTPException raise করুন — পর্ব ২৪-এর মতো একটি সাধারণ exception, যা FastAPI ধরে সঠিক response বানায়:

1@app.get("/products/{product_id}")2def get_product(product_id: int) -> Product:3    if product_id not in products:4        raise HTTPException(status_code=404,5                            detail="প্রোডাক্ট পাওয়া যায়নি")6    return products[product_id]

পুরো CRUD — দোকানের প্রোডাক্ট API

ডেটা নিয়ে চারটি মৌলিক কাজ — Create, Read, Update, Delete — একসাথে CRUD. REST নামের নকশা-রীতিতে এগুলো HTTP method-এর সাথে মেলে: একটি “resource” (/products), আর method বলে কী করতে হবে। সব একসাথে, ডেটা আপাতত একটি dict-এ (server বন্ধ হলে মুছে যাবে — অংশ ৮-এ ডেটাবেস):

from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel, Field

app = FastAPI(title="দোকানের প্রোডাক্ট API")

class ProductIn(BaseModel):
    name: str = Field(min_length=1, max_length=50)
    price: float = Field(gt=0)
    stock: int = Field(default=0, ge=0)

class Product(ProductIn):
    id: int

products: dict[int, Product] = {
    7: Product(id=7, name="চাল (৫ কেজি)", price=420, stock=12),
}
next_id = 8

def find_or_404(product_id: int) -> Product:
    if product_id not in products:
        raise HTTPException(status_code=404, detail="প্রোডাক্ট পাওয়া যায়নি")
    return products[product_id]

@app.get("/products")                                       # Read (তালিকা)
def list_products(max_price: float | None = None, limit: int = 10) -> list[Product]:
    items = [p for p in products.values() if max_price is None or p.price <= max_price]
    return items[:limit]

@app.get("/products/{product_id}")                          # Read (একটি)
def get_product(product_id: int) -> Product:
    return find_or_404(product_id)

@app.post("/products", status_code=status.HTTP_201_CREATED) # Create
def create_product(data: ProductIn) -> Product:
    global next_id
    product = Product(id=next_id, **data.model_dump())
    products[next_id] = product
    next_id += 1
    return product

@app.put("/products/{product_id}")                          # Update
def update_product(product_id: int, data: ProductIn) -> Product:
    find_or_404(product_id)
    products[product_id] = Product(id=product_id, **data.model_dump())
    return products[product_id]

@app.delete("/products/{product_id}", status_code=204)      # Delete
def delete_product(product_id: int) -> None:
    find_or_404(product_id)
    del products[product_id]

এই API-তে পরপর কয়েকটি request পাঠালে (FastAPI 0.143 আর pydantic 2.14-এ TestClient দিয়ে যাচাই করা আসল উত্তর):

POST   /products  {"name": "ডাল", "price": 140}   → 201 {"name": "ডাল", "price": 140.0, "stock": 0, "id": 8}
GET    /products?max_price=200                   → 200 [{"name": "ডাল", "price": 140.0, "stock": 0, "id": 8}]
PUT    /products/8 {"name": "মসুর ডাল", "price": 150, "stock": 5}
                                                 → 200 {"name": "মসুর ডাল", "price": 150.0, "stock": 5, "id": 8}
DELETE /products/8                               → 204 (body নেই)
DELETE /products/8                               → 404 {"detail": "প্রোডাক্ট পাওয়া যায়নি"}

শেষ দুই লাইন লক্ষ করুন। একই DELETE দ্বিতীয়বার পাঠালে ৪০৪ — কিন্তু সার্ভারের অবস্থা দুইবারেই এক (প্রোডাক্ট ৮ নেই)। এই গুণকে বলে idempotent: একই request একবার পাঠানো আর দশবার পাঠানোর ফল সার্ভারের দিক থেকে এক। GET, PUT, DELETE idempotent হওয়ার কথা; POST নয় — দুবার পাঠালে দুটি প্রোডাক্ট তৈরি হয়। দুর্বল নেটওয়ার্কে মোবাইল অ্যাপ যখন request আবার পাঠায়, এই পার্থক্য বড় হয়ে ওঠে: bKash-এ টাকা পাঠানোর মতো কাজ দুবার হয়ে যাওয়া মানে বিপদ, তাই পেমেন্ট API-গুলো আলাদা “idempotency key” ব্যবহার করে।

একই ছাঁচে আরও দুটি API

৭ · Depends, async def আর টেস্টিং

Dependency injection — handler নিজে জিনিস বানায় না, চেয়ে নেয়

বাস্তব ব্যাকএন্ডে প্রায় প্রতিটি handler-এর কিছু “সরঞ্জাম” লাগে: একটি ডেটাবেস সংযোগ, বর্তমান ব্যবহারকারী কে, সেটিংস। প্রতিটি ফাংশনে নিজে নিজে সংযোগ খোলা আর বন্ধ করা মানে একই কোড বারবার, আর কোথাও বন্ধ করতে ভুলে যাওয়ার ঝুঁকি। FastAPI-র সমাধান dependency injection: handler শুধু বলে “আমার একটি db লাগবে”, আর ফ্রেমওয়ার্ক সেটি বানিয়ে দেয়, কাজ শেষে গুছিয়ে নেয়। পরীক্ষার ফলের API দিয়ে দেখুন:

1def get_db():2    db = ResultDB()           # সংযোগ খোলা3    try:4        yield db5    finally:6        db.close()            # সবসময় বন্ধ78@app.get("/results/{roll}")9def result(roll: int, db: ResultDB = Depends(get_db)):10    r = db.get_result(roll)11    if r is None:12        raise HTTPException(404, "এই রোলের ফল নেই")13    return r

async def না def?

FastAPI-তে handler দুইভাবেই লেখা যায়, আর দুটিই ঠিক — কিন্তু নিয়ম না জানলে বিপদ:

• async def — handler সরাসরি event loop-এ চলে (পর্ব ৪২)। ভেতরে শুধু await-যোগ্য কাজ করুন: async ডেটাবেস ড্রাইভার, httpx.AsyncClient দিয়ে অন্য API ডাকা, asyncio.sleep.
• def — FastAPI handler-টিকে একটি আলাদা thread pool-এ চালায়, যাতে event loop আটকে না যায়। সাধারণ (blocking) লাইব্রেরি — sqlite3, requests, ফাইল পড়া — ব্যবহার করলে এটিই নিরাপদ।

টেস্টিং — server না চালিয়েই

পর্ব ৩৯-এর pytest এখানে সরাসরি কাজে লাগে। FastAPI-র TestClient নেটওয়ার্ক বা আসল server ছাড়াই আপনার app-কে request পাঠায় — অংশ ২-এ আমরা যেমন নকল environ দিয়ে WSGI app ডেকেছিলাম, অনেকটা তেমন:

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_get_existing_product():
    r = client.get("/products/7")
    assert r.status_code == 200
    assert r.json()["name"] == "চাল (৫ কেজি)"

def test_missing_product_is_404():
    assert client.get("/products/999").status_code == 404

def test_negative_price_rejected():
    r = client.post("/products", json={"name": "ডাল", "price": -5})
    assert r.status_code == 422

$ pytest -q
...                                                    [100%]
3 passed

লক্ষ করুন, তিনটির মধ্যে দুটি টেস্ট ব্যর্থতার পথ যাচাই করছে — ৪০৪ আর ৪২২. ব্যাকএন্ডে সুখী পথ সাধারণত নিজে থেকেই কাজ করে; বাগ লুকিয়ে থাকে ভুল id, খালি field, ঋণাত্মক দাম আর অনুমতিহীন request-এ। (TestClient চালাতে httpx প্যাকেজ লাগে, যা fastapi[standard]-এর সাথে আসে।)

৮ · ডেটাবেস, নিরাপত্তা আর deployment — খেলনা থেকে আসল সার্ভিস

ডেটাবেসের ঝলক

আমাদের dict server বন্ধ হলেই মুছে যায়, আর একাধিক worker থাকলে প্রত্যেকের dict আলাদা। আসল ডেটা থাকে একটি database-এ। শুরুর জন্য সবচেয়ে সহজ পর্ব ২৭-এ দেখা SQLite — Python-এর সাথেই আসা sqlite3 module, একটি ফাইলেই পুরো ডেটাবেস। def handler-এ (thread pool, তাই blocking চলবে) একটি query দেখতে এমন:

import sqlite3

@app.get("/products/{product_id}")
def get_product(product_id: int):
    with sqlite3.connect("shop.db") as conn:
        row = conn.execute(
            "SELECT id, name, price FROM products WHERE id = ?", (product_id,)
        ).fetchone()
    if row is None:
        raise HTTPException(status_code=404, detail="প্রোডাক্ট পাওয়া যায়নি")
    return {"id": row[0], "name": row[1], "price": row[2]}

? চিহ্নটি গুরুত্বপূর্ণ: মানটি আলাদা করে পাঠানো হয় (parameterized query), f-string দিয়ে SQL-এ জোড়া হয় না — তাই SQL injection-এর পথ বন্ধ। (এখানে product_id আগেই int, কিন্তু string parameter-এ এই নিয়ম জীবন বাঁচায়।) প্রজেক্ট বড় হলে সাধারণত একটি ORM ব্যবহার হয় — SQL না লিখে Python class দিয়ে টেবিল। FastAPI-র নির্মাতারই বানানো SQLModel একই class-কে pydantic model আর ডেটাবেস টেবিল দুটোই বানায়; আরও প্রচলিত বিকল্প SQLAlchemy. টেবিলের নকশা, ORM আর migration-এর গভীরে যেতে দেখুন ORM প্যাটার্ন.

নিরাপত্তার মূল নিয়ম — রক্ষণাত্মক দৃষ্টিতে

আপনার API ইন্টারনেটে গেলে যে কেউ যেকোনো request পাঠাতে পারে — আপনার অ্যাপ দিয়ে নয়, সরাসরি। তাই প্রথম নিয়ম: client-কে কখনো বিশ্বাস করবেন না। মোবাইল অ্যাপে দাম ঋণাত্মক দেওয়া যায় না বলে সার্ভারে যাচাই বাদ দেওয়া চলবে না; কেউ অ্যাপ ছাড়াই {"price": -5} পাঠাতে পারেন। পর্ব ৫০-এ নিরাপদ Python নিয়ে বিস্তারিত আসবে; ব্যাকএন্ডের জন্য এখনই যা মানবেন:

• প্রতিটি input যাচাই: pydantic model আর Field-এর সীমা (gt, max_length) দিয়ে — দৈর্ঘ্যের সীমাও দিন, যাতে কেউ এক কোটি অক্ষরের নাম পাঠিয়ে সার্ভার ভারী করতে না পারে (input validation).
• Stack trace বাইরে নয়: error-এ client পাবে শুধু {"detail": "..."}; বিস্তারিত traceback যাবে সার্ভারের log-এ (পর্ব ৪০)। Production-এ কোনো debug mode চালু রাখবেন না — traceback-এ ফাইলের পথ, কোড, কখনো গোপন মানও দেখা যায়।
• Secret কোডে নয়: ডেটাবেসের password, API key রাখুন environment variable-এ (os.environ["DATABASE_URL"]), কোডে বা git-এ কখনো নয়।
• CORS বুঝে খুলুন: ব্রাউজার নিরাপত্তার জন্য অন্য domain-এর পেজকে আপনার API পড়তে দেয় না, যদি না সার্ভার অনুমতি দেয় — এই নিয়ম হলো CORS. FastAPI-র CORSMiddleware-এ শুধু নিজের frontend-এর domain দিন; allow_origins=["*"] সব domain-কে খুলে দেয়।
• Authentication নিজে আবিষ্কার নয়: লগইন, token, password-এর hash — এগুলোর জন্য মানক আছে (OAuth2, JWT) আর পরীক্ষিত লাইব্রেরি আছে। নিজের বানানো “গোপন” পদ্ধতি প্রায় সবসময় ভাঙা যায়। FastAPI-র ডকুমেন্টেশনে fastapi.security-এর নির্দেশনা অনুসরণ করুন।
• দরজায় তালা: শুধু HTTPS, আর ডেটা বদলানোর প্রতিটি endpoint-এ পরিচয় ও অনুমতি যাচাই — “কেউ ঠিকানা জানবে না” কোনো নিরাপত্তা নয়।

Deployment — এক অনুচ্ছেদে

নিজের কম্পিউটার থেকে ইন্টারনেটে নিতে দরকার একটি সব সময় চালু থাকা কম্পিউটার: একটি VPS (ভাড়া করা Linux সার্ভার, যেখানে সব নিজে সাজান) অথবা একটি PaaS (প্ল্যাটফর্ম, যেখানে কোড দিলেই চালিয়ে দেয়)। সেখানে --reload ছাড়া uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4 বা fastapi run চলে, প্রায়ই একটি Docker container-এর ভেতরে; সামনে থাকে Nginx বা Caddy-র মতো একটি reverse proxy, যে HTTPS-এর সার্টিফিকেট (যেমন Let's Encrypt-এর বিনামূল্যের সার্টিফিকেট) সামলায়। সব secret আর সেটিংস যায় environment variable-এ, আর log যায় একটি নির্দিষ্ট জায়গায়, যাতে রাত তিনটায় কিছু ভাঙলে সকালে কারণ খুঁজে পাওয়া যায়। Container, CI/CD আর secret ব্যবস্থাপনার বিস্তারিত পাবেন environment ও secret ব্যবস্থাপনা পর্বে।

৯ · AI-এর যুগে — AI-এর লেখা API যাচাই করা

“একটি FastAPI CRUD API লিখে দাও” — AI কয়েক সেকেন্ডে লিখে দেবে, আর তা চলবেও। সমস্যা হলো, “চলে” আর “নিরাপদে, সঠিকভাবে চলে” এক জিনিস নয়। AI-এর প্রশিক্ষণের ডেটায় পুরোনো Flask আর FastAPI-র টিউটোরিয়াল প্রচুর, আর অনেক টিউটোরিয়াল ইচ্ছা করেই যাচাই আর নিরাপত্তা বাদ দেয়, যাতে উদাহরণ ছোট থাকে। ফলে কিছু ভুল বারবার দেখা যায়:

AI-এর লেখা ব্যাকএন্ড পেলে — যাচাইয়ের চেকলিস্ট

• নিজের কম্পিউটারে চালিয়ে /docs খুলেছি — প্রতিটি endpoint-এর input আর output model ঠিক আছে কি না দেখেছি
• ইচ্ছা করে ভুল ডেটা পাঠিয়েছি (ঋণাত্মক দাম, খালি নাম, ভুল type, অচেনা id) — ৪২২ আর ৪০৪ আসছে, ২০০ বা ৫০০ নয়
• .dict(), orm_mode, on_event-এর মতো পুরোনো API খুঁজেছি (Ctrl+F)
• কোডে কোনো password, key বা token লেখা নেই — সব environment variable থেকে আসে
• প্রতিটি async def-এর ভেতরে blocking call আছে কি না পড়ে দেখেছি
• response-এ এমন কোনো field যাচ্ছে না, যা client-এর দেখার কথা নয় (password hash, কেনা দাম)
• টেস্ট নিজে চালিয়েছি, আর ব্যর্থতার পথের টেস্ট আছে কি না দেখেছি